stop SF rest code using any legacy Requests logic

guardian · Sep 25, 2018 · 0985ac3 · 0985ac3
1 parent 46fc2fe
commit 0985ac3
Show file tree

Hide file tree

Showing 17 changed files with 232 additions and 218 deletions.
diff --git a/handlers/cancellation-sf-cases/src/main/scala/com/gu/cancellation/sf_cases/Handler.scala b/handlers/cancellation-sf-cases/src/main/scala/com/gu/cancellation/sf_cases/Handler.scala
@@ -8,10 +8,9 @@ import com.gu.cancellation.sf_cases.TypeConvert._
 import com.gu.effects.{GetFromS3, RawEffects}
 import com.gu.identity.IdentityCookieToIdentityUser.{CookieValuesToIdentityUser, IdentityId, IdentityUser}
 import com.gu.identity.{IdentityCookieToIdentityUser, IdentityTestUserConfig, IsIdentityTestUser}
-import com.gu.salesforce.SalesforceGenericIdLookup
+import com.gu.salesforce.{JsonHttp, SalesforceClient, SalesforceGenericIdLookup}
 import com.gu.salesforce.SalesforceGenericIdLookup.{FieldName, LookupValue, SfObjectType, TSalesforceGenericIdLookup}
-import com.gu.salesforce.auth.SalesforceAuthenticate
-import com.gu.salesforce.auth.SalesforceAuthenticate.{SFAuthConfig, SFAuthTestConfig}
+import com.gu.salesforce.SalesforceAuthenticate.{SFAuthConfig, SFAuthTestConfig}
 import com.gu.salesforce.cases.SalesforceCase
 import com.gu.salesforce.cases.SalesforceCase.Create.WireNewCase
 import com.gu.salesforce.cases.SalesforceCase.GetMostRecentCaseByContactId.TGetMostRecentCaseByContactId
@@ -30,18 +29,16 @@ import play.api.libs.json._
 
 object Handler extends Logging {
 
-  case class IdentityAndSfRequests(identityUser: IdentityUser, sfRequests: SfRequestMethods)
-  case class SfRequestMethods(
-    post: HttpOp[RestRequestMaker.PostRequest, JsValue],
-    patch: HttpOp[RestRequestMaker.PatchRequest, Unit],
-    get: HttpOp[RestRequestMaker.GetRequest, JsValue]
+  case class IdentityAndSfRequests(
+    identityUser: IdentityUser,
+    sfRequests: HttpOp[JsonHttp.HttpRequestInfo, RestRequestMaker.BodyAsString]
   )
 
   type HeadersOption = Option[Map[String, String]]
   type IdentityAndSfRequestsApiGatewayOp = ApiGatewayOp[IdentityAndSfRequests]
   type SfBackendForIdentityCookieHeader = HeadersOption => IdentityAndSfRequestsApiGatewayOp
   type Steps = SfBackendForIdentityCookieHeader => ApiGatewayRequest => ApiResponse
-  type LazySalesforceAuthenticatedReqMaker = () => ApiGatewayOp[SfRequestMethods]
+  type LazySalesforceAuthenticatedReqMaker = () => ApiGatewayOp[HttpOp[JsonHttp.HttpRequestInfo, RestRequestMaker.BodyAsString]]
   case class SfRequests(normal: LazySalesforceAuthenticatedReqMaker, test: LazySalesforceAuthenticatedReqMaker)
 
   def raiseCase(inputStream: InputStream, outputStream: OutputStream, context: Context): Unit =
@@ -161,11 +158,11 @@ object Handler extends Logging {
       (for {
         identityAndSfRequests <- sfBackendForIdentityCookieHeader(apiGatewayRequest.headers)
         raiseCaseDetail <- apiGatewayRequest.bodyAsCaseClass[RaiseCaseDetail]()
-        lookupByIdOp = SalesforceGenericIdLookup(identityAndSfRequests.sfRequests.get)
-        mostRecentCaseOp = SalesforceCase.GetMostRecentCaseByContactId(identityAndSfRequests.sfRequests.get)
-        createCaseOp = SalesforceCase.Create(identityAndSfRequests.sfRequests.post)
+        lookupByIdOp = SalesforceGenericIdLookup(identityAndSfRequests.sfRequests.wrap(JsonHttp.get))
+        mostRecentCaseOp = SalesforceCase.GetMostRecentCaseByContactId(identityAndSfRequests.sfRequests.wrap(JsonHttp.get))
+        createCaseOp = SalesforceCase.Create(identityAndSfRequests.sfRequests.wrap(JsonHttp.post))
         wiredCreateCaseOp = buildWireNewCaseForSalesforce.tupled andThen createCaseOp
-        sfUpdateOp = SalesforceCase.Update(identityAndSfRequests.sfRequests.patch)
+        sfUpdateOp = SalesforceCase.Update(identityAndSfRequests.sfRequests.wrap(JsonHttp.patch))
         updateReasonOnRecentCaseOp = updateCaseReason(sfUpdateOp)_
         newOrResumeCaseOp = newOrResumeCase(wiredCreateCaseOp, updateReasonOnRecentCaseOp, raiseCaseDetail)_
         wiredRaiseCase = raiseCase(lookupByIdOp, mostRecentCaseOp, newOrResumeCaseOp)_
@@ -215,11 +212,11 @@ object Handler extends Logging {
       (for {
         identityAndSfRequests <- sfBackendForIdentityCookieHeader(apiGatewayRequest.headers)
         pathParams <- apiGatewayRequest.pathParamsAsCaseClass[CasePathParams]()
-        lookupByIdOp = SalesforceGenericIdLookup(identityAndSfRequests.sfRequests.get)
-        getCaseByIdOp = SalesforceCase.GetById[CaseWithContactId](identityAndSfRequests.sfRequests.get)_
+        lookupByIdOp = SalesforceGenericIdLookup(identityAndSfRequests.sfRequests.wrap(JsonHttp.get))
+        getCaseByIdOp = SalesforceCase.GetById[CaseWithContactId](identityAndSfRequests.sfRequests.wrap(JsonHttp.get))_
         _ <- verifyCaseBelongsToUser(lookupByIdOp, getCaseByIdOp)(identityAndSfRequests.identityUser.id, pathParams.caseId)
         requestBody <- apiGatewayRequest.bodyAsCaseClass[JsValue]()
-        sfUpdateOp = SalesforceCase.Update(identityAndSfRequests.sfRequests.patch)
+        sfUpdateOp = SalesforceCase.Update(identityAndSfRequests.sfRequests.wrap(JsonHttp.patch))
         _ <- sfUpdateOp(pathParams.caseId, requestBody).toApiGatewayOp("update case")
       } yield ApiGatewayResponse.successfulExecution).apiResponse
 
@@ -261,22 +258,14 @@ object Handler extends Logging {
         val sfRequestsNormal: LazySalesforceAuthenticatedReqMaker = () =>
           for {
             config <- loadNormalSfConfig.toApiGatewayOp("load 'normal' SF config")
-            sfAuth <- SalesforceAuthenticate.doAuth(response, config)
-          } yield SfRequestMethods(
-            SalesforceAuthenticate.post(response, sfAuth),
-            SalesforceAuthenticate.patch(response, sfAuth),
-            SalesforceAuthenticate.get(response, sfAuth)
-          )
+            sfAuth <- SalesforceClient(response, config).value.toApiGatewayOp("Failed to authenticate with Salesforce")
+          } yield sfAuth
 
         val sfRequestsTest: LazySalesforceAuthenticatedReqMaker = () =>
           for {
             config <- loadTestSfConfig.toApiGatewayOp("load 'test' SF config")
-            sfAuth <- SalesforceAuthenticate.doAuth(response, config)
-          } yield SfRequestMethods(
-            SalesforceAuthenticate.post(response, sfAuth),
-            SalesforceAuthenticate.patch(response, sfAuth),
-            SalesforceAuthenticate.get(response, sfAuth)
-          )
+            sfAuth <- SalesforceClient(response, config).value.toApiGatewayOp("Failed to authenticate with Salesforce")
+          } yield sfAuth
 
         def sfBackendForIdentityCookieHeader(headers: HeadersOption): IdentityAndSfRequestsApiGatewayOp = {
           for {

diff --git a/...ion-sf-cases/src/test/scala/com/gu/cancellation/sf_cases/EndToEndHandlerEffectsTest.scala b/...ion-sf-cases/src/test/scala/com/gu/cancellation/sf_cases/EndToEndHandlerEffectsTest.scala
@@ -6,6 +6,7 @@ import com.gu.cancellation.sf_cases.Handler.{CasePathParams, SfBackendForIdentit
 import com.gu.cancellation.sf_cases.TypeConvert._
 import com.gu.effects.{GetFromS3, RawEffects}
 import com.gu.identity.IdentityCookieToIdentityUser.{IdentityId, IdentityUser}
+import com.gu.salesforce.JsonHttp
 import com.gu.salesforce.cases.SalesforceCase
 import com.gu.salesforce.cases.SalesforceCase.CaseWithId
 import com.gu.test.EffectsTest
@@ -28,7 +29,7 @@ class EndToEndHandlerEffectsTest extends FlatSpec with Matchers {
     (for {
       identityAndSfRequests <- sfBackendForIdentityCookieHeader(apiGatewayRequest.headers)
       pathParams <- apiGatewayRequest.pathParamsAsCaseClass[CasePathParams]()
-      sfGet = SalesforceCase.GetById[JsValue](identityAndSfRequests.sfRequests.get)_
+      sfGet = SalesforceCase.GetById[JsValue](identityAndSfRequests.sfRequests.wrap(JsonHttp.get))_
       getCaseResponse <- sfGet(pathParams.caseId).toApiGatewayOp("get case detail")
     } yield ApiGatewayResponse("200", getCaseResponse)).apiResponse
 

diff --git a/handlers/identity-backfill/src/main/scala/com/gu/identityBackfill/Handler.scala b/handlers/identity-backfill/src/main/scala/com/gu/identityBackfill/Handler.scala
@@ -11,18 +11,19 @@ import com.gu.identityBackfill.salesforce.ContactSyncCheck.RecordTypeId
 import com.gu.identityBackfill.salesforce.UpdateSalesforceIdentityId.IdentityId
 import com.gu.identityBackfill.salesforce._
 import com.gu.identityBackfill.zuora.{AddIdentityIdToAccount, CountZuoraAccountsForIdentityId, GetZuoraAccountsForEmail, GetZuoraSubTypeForAccount}
+import com.gu.salesforce.{JsonHttp, SalesforceClient}
 import com.gu.salesforce.TypesForSFEffectsData.SFContactId
-import com.gu.salesforce.auth.SalesforceAuthenticate
-import com.gu.salesforce.auth.SalesforceAuthenticate.SFAuthConfig
+import com.gu.salesforce.JsonHttp.HttpRequestInfo
+import com.gu.salesforce.SalesforceAuthenticate.SFAuthConfig
 import com.gu.util.apigateway.ApiGatewayHandler.{LambdaIO, Operation}
 import com.gu.util.apigateway.ResponseModels.ApiResponse
 import com.gu.util.apigateway.{ApiGatewayHandler, ApiGatewayResponse}
 import com.gu.util.config.LoadConfigModule.StringFromS3
 import com.gu.util.config.{LoadConfigModule, Stage}
 import com.gu.util.reader.Types._
-import com.gu.util.resthttp.HttpOp
 import com.gu.util.resthttp.RestRequestMaker.{GetRequest, PatchRequest}
 import com.gu.util.resthttp.Types.ClientFailableOp
+import com.gu.util.resthttp.{HttpOp, LazyClientFailableOp, RestRequestMaker}
 import com.gu.util.zuora.{ZuoraQuery, ZuoraRestConfig, ZuoraRestRequestMaker}
 import okhttp3.{Request, Response}
 import play.api.libs.json.JsValue
@@ -55,9 +56,9 @@ object Handler {
       val getByEmail: EmailAddress => GetByEmail.ApiError \/ IdentityId = GetByEmail(response, identityConfig)
       val countZuoraAccounts: IdentityId => ClientFailableOp[Int] = CountZuoraAccountsForIdentityId(zuoraQuerier)
 
-      lazy val sfAuth: ApiGatewayOp[SalesforceAuthenticate.SalesforceAuth] = SalesforceAuthenticate.doAuth(response, sfConfig)
-      lazy val sfPatch = sfAuth.map(salesforceAuth => SalesforceAuthenticate.patch(response, salesforceAuth))
-      lazy val sfGet = sfAuth.map(salesforceAuth => SalesforceAuthenticate.get(response, salesforceAuth))
+      lazy val sfAuth: LazyClientFailableOp[HttpOp[HttpRequestInfo, RestRequestMaker.BodyAsString]] = SalesforceClient(response, sfConfig)
+      lazy val sfPatch = sfAuth.map(_.wrap(JsonHttp.patch))
+      lazy val sfGet = sfAuth.map(_.wrap(JsonHttp.get))
 
       Operation(
         steps = IdentityBackfillSteps(
@@ -100,23 +101,23 @@ object Handler {
       .toApiGatewayContinueProcessing(ApiGatewayResponse.internalServerError(s"missing standard record type for stage $stage"))
   }
 
-  def syncableSFToIdentity(sfRequests: ApiGatewayOp[HttpOp[GetRequest, JsValue]], stage: Stage)(sFContactId: SFContactId): ApiGatewayOp[Unit] =
+  def syncableSFToIdentity(sfRequests: LazyClientFailableOp[HttpOp[GetRequest, JsValue]], stage: Stage)(sFContactId: SFContactId): ApiGatewayOp[Unit] =
     for {
-      sfRequests <- sfRequests
+      sfRequests <- sfRequests.value.toApiGatewayOp("Failed to authenticate with Salesforce")
       standardRecordType <- standardRecordTypeForStage(stage)
       fields <- GetSFContactSyncCheckFields(sfRequests).apply(sFContactId).value
         .toApiGatewayOp("get contact from salesforce")
       syncable <- SyncableSFToIdentity(standardRecordType)(fields)(sFContactId)
     } yield syncable
 
   def updateSalesforceIdentityId(
-    sfRequests: ApiGatewayOp[HttpOp[PatchRequest, Unit]]
+    sfRequests: LazyClientFailableOp[HttpOp[PatchRequest, Unit]]
   )(
     sFContactId: SFContactId,
     identityId: IdentityId
   ): ApiGatewayOp[Unit] =
     for {
-      sfRequests <- sfRequests
+      sfRequests <- sfRequests.value.toApiGatewayOp("Failed to authenticate with Salesforce")
       _ <- UpdateSalesforceIdentityId(sfRequests).runRequestMultiArg(sFContactId, identityId)
         .toApiGatewayOp("update identity id in salesforce")
     } yield ()
@@ -127,13 +128,13 @@ object Healthcheck {
   def apply(
     getByEmail: EmailAddress => \/[GetByEmail.ApiError, IdentityId],
     countZuoraAccountsForIdentityId: IdentityId => ClientFailableOp[Int],
-    sfAuth: => ApiGatewayOp[Any]
+    sfAuth: => LazyClientFailableOp[Any]
   ): ApiResponse =
     (for {
       identityId <- getByEmail(EmailAddress("john.duffell@guardian.co.uk"))
         .toApiGatewayOp("problem with email").withLogging("healthcheck getByEmail")
       _ <- countZuoraAccountsForIdentityId(identityId).toApiGatewayOp("get zuora accounts for identity id")
-      _ <- sfAuth
+      _ <- sfAuth.value.toApiGatewayOp("Failed to authenticate with Salesforce")
     } yield ApiGatewayResponse.successfulExecution).apiResponse
 
 }
diff --git a/...om/gu/identityBackfill/salesforce/getContact/GetSFContactSyncCheckFieldsEffectsTest.scala b/...om/gu/identityBackfill/salesforce/getContact/GetSFContactSyncCheckFieldsEffectsTest.scala
@@ -1,30 +1,28 @@
 package com.gu.identityBackfill.salesforce.getContact
 
 import com.gu.effects.{GetFromS3, RawEffects}
-import com.gu.identityBackfill.TypeConvert._
-import com.gu.identityBackfill.salesforce.GetSFContactSyncCheckFields.ContactSyncCheckFields
 import com.gu.identityBackfill.salesforce.GetSFContactSyncCheckFields
-import com.gu.salesforce.auth.SalesforceAuthenticate
-import com.gu.salesforce.auth.SalesforceAuthenticate.SFAuthConfig
+import com.gu.identityBackfill.salesforce.GetSFContactSyncCheckFields.ContactSyncCheckFields
+import com.gu.salesforce.{JsonHttp, SalesforceClient}
+import com.gu.salesforce.SalesforceAuthenticate.SFAuthConfig
 import com.gu.salesforce.dev.SFEffectsData
 import com.gu.test.EffectsTest
 import com.gu.util.config.{LoadConfigModule, Stage}
 import org.scalatest.{FlatSpec, Matchers}
 import scalaz.\/-
-import com.gu.util.reader.Types._
 
 class GetSFContactSyncCheckFieldsEffectsTest extends FlatSpec with Matchers {
 
   it should "get auth SF correctly" taggedAs EffectsTest in {
 
     val actual = for {
-      sfConfig <- LoadConfigModule(Stage("DEV"), GetFromS3.fetchString)[SFAuthConfig].toApiGatewayOp("parse config")
-      sfAuth <- SalesforceAuthenticate.doAuth(RawEffects.response, sfConfig)
-      getOp = SalesforceAuthenticate.get(RawEffects.response, sfAuth)
-      result <- GetSFContactSyncCheckFields(getOp).apply(SFEffectsData.testContactHasNamePhoneOtherAddress).value.toApiGatewayOp("failed")
+      sfConfig <- LoadConfigModule(Stage("DEV"), GetFromS3.fetchString)[SFAuthConfig]
+      sfAuth <- SalesforceClient(RawEffects.response, sfConfig).value.toDisjunction
+      getOp = sfAuth.wrap(JsonHttp.get)
+      result <- GetSFContactSyncCheckFields(getOp).apply(SFEffectsData.testContactHasNamePhoneOtherAddress).value.toDisjunction
     } yield result
 
-    actual.toDisjunction should be(\/-(ContactSyncCheckFields(None, "One", "Day", Some("Afghanistan"))))
+    actual should be(\/-(ContactSyncCheckFields(None, "One", "Day", Some("Afghanistan"))))
 
   }
 

diff --git a/...dentityBackfill/salesforce/updateSFIdentityId/UpdateSalesforceIdentityIdEffectsTest.scala b/...dentityBackfill/salesforce/updateSFIdentityId/UpdateSalesforceIdentityIdEffectsTest.scala
@@ -3,8 +3,8 @@ package com.gu.identityBackfill.salesforce.updateSFIdentityId
 import com.gu.effects.{GetFromS3, RawEffects}
 import com.gu.identityBackfill.salesforce.UpdateSalesforceIdentityId
 import com.gu.identityBackfill.salesforce.UpdateSalesforceIdentityId.IdentityId
-import com.gu.salesforce.auth.SalesforceAuthenticate
-import com.gu.salesforce.auth.SalesforceAuthenticate.SFAuthConfig
+import com.gu.salesforce.{JsonHttp, SalesforceClient}
+import com.gu.salesforce.SalesforceAuthenticate.SFAuthConfig
 import com.gu.salesforce.dev.SFEffectsData
 import com.gu.test.EffectsTest
 import com.gu.util.config.{LoadConfigModule, Stage}
@@ -23,10 +23,10 @@ class UpdateSalesforceIdentityIdEffectsTest extends FlatSpec with Matchers {
     val actual = for {
       sfConfig <- LoadConfigModule(Stage("DEV"), GetFromS3.fetchString)[SFAuthConfig]
       response = RawEffects.response
-      auth <- SalesforceAuthenticate.doAuth(response, sfConfig).toDisjunction
-      updateSalesforceIdentityId = UpdateSalesforceIdentityId(SalesforceAuthenticate.patch(response, auth))
+      auth <- SalesforceClient(response, sfConfig).value.toDisjunction
+      updateSalesforceIdentityId = UpdateSalesforceIdentityId(auth.wrap(JsonHttp.patch))
       _ <- updateSalesforceIdentityId.runRequestMultiArg(testContact, IdentityId(unique)).toDisjunction
-      getSalesforceIdentityId = GetSalesforceIdentityId(SalesforceAuthenticate.get(response, auth))
+      getSalesforceIdentityId = GetSalesforceIdentityId(auth.wrap(JsonHttp.get))
       identityId <- getSalesforceIdentityId(testContact).value.toDisjunction
     } yield identityId
 

diff --git a/handlers/sf-contact-merge/src/main/scala/com/gu/sf_contact_merge/Handler.scala b/handlers/sf-contact-merge/src/main/scala/com/gu/sf_contact_merge/Handler.scala
@@ -4,17 +4,17 @@ import java.io.{InputStream, OutputStream}
 
 import com.amazonaws.services.lambda.runtime.Context
 import com.gu.effects.{GetFromS3, RawEffects}
+import com.gu.salesforce.{JsonHttp, SalesforceClient}
 import com.gu.salesforce.TypesForSFEffectsData.SFContactId
-import com.gu.salesforce.auth.SalesforceAuthenticate
-import com.gu.salesforce.auth.SalesforceAuthenticate.SFAuthConfig
+import com.gu.salesforce.SalesforceAuthenticate.SFAuthConfig
 import com.gu.sf_contact_merge.TypeConvert._
 import com.gu.sf_contact_merge.WireRequestToDomainObject.MergeRequest
 import com.gu.sf_contact_merge.getaccounts.GetContacts.AccountId
 import com.gu.sf_contact_merge.getaccounts.GetIdentityAndZuoraEmailsForAccountsSteps
 import com.gu.sf_contact_merge.getaccounts.GetIdentityAndZuoraEmailsForAccountsSteps.IdentityAndSFContactAndEmail
 import com.gu.sf_contact_merge.getaccounts.GetZuoraContactDetails.{EmailAddress, LastName}
 import com.gu.sf_contact_merge.getsfcontacts.DedupSfContacts.SFContactsForMerge
-import com.gu.sf_contact_merge.getsfcontacts.{GetSfAddress, GetSfAddressOverride, DedupSfContacts}
+import com.gu.sf_contact_merge.getsfcontacts.{DedupSfContacts, GetSfAddress, GetSfAddressOverride}
 import com.gu.sf_contact_merge.update.UpdateAccountSFLinks.{CRMAccountId, LinksFromZuora}
 import com.gu.sf_contact_merge.update.UpdateSFContacts.OldSFContact
 import com.gu.sf_contact_merge.update.{UpdateAccountSFLinks, UpdateSFContacts, UpdateSalesforceIdentityId}
@@ -49,9 +49,7 @@ object Handler {
       zuoraQuerier = ZuoraQuery(requests)
 
       sfConfig <- loadConfig[SFAuthConfig].toApiGatewayOp("load trusted Api config")
-      sfAuth <- SalesforceAuthenticate.doAuth(getResponse, sfConfig)
-      sfPatch = SalesforceAuthenticate.patch(getResponse, sfAuth)
-      sfGet = SalesforceAuthenticate.get(getResponse, sfAuth)
+      sfAuth <- SalesforceClient(getResponse, sfConfig).value.toApiGatewayOp("Failed to authenticate with Salesforce")
 
     } yield Operation.noHealthcheck {
       WireRequestToDomainObject {
@@ -60,11 +58,11 @@ object Handler {
           AssertSame.emailAddress,
           AssertSame.lastName,
           EnsureNoAccountWithWrongIdentityId.apply,
-          UpdateSFContacts(UpdateSalesforceIdentityId(sfPatch)),
+          UpdateSFContacts(UpdateSalesforceIdentityId(sfAuth.wrap(JsonHttp.patch))),
           UpdateAccountSFLinks(requests.put),
           GetSfAddressOverride.apply,
           DedupSfContacts.apply,
-          GetSfAddress(sfGet)
+          GetSfAddress(sfAuth.wrap(JsonHttp.get))
         )
       }
     }

diff --git a/...-merge/src/test/scala/com/gu/sf_contact_merge/getsfcontacts/GetSfAddressEffectsTest.scala b/...-merge/src/test/scala/com/gu/sf_contact_merge/getsfcontacts/GetSfAddressEffectsTest.scala
@@ -1,11 +1,11 @@
 package com.gu.sf_contact_merge.getsfcontacts
 
 import com.gu.effects.{GetFromS3, RawEffects}
-import com.gu.salesforce.auth.SalesforceAuthenticate
-import com.gu.salesforce.auth.SalesforceAuthenticate.SFAuthConfig
+import com.gu.salesforce.{JsonHttp, SalesforceClient}
+import com.gu.salesforce.SalesforceAuthenticate.SFAuthConfig
 import com.gu.salesforce.dev.SFEffectsData
-import com.gu.sf_contact_merge.getsfcontacts.GetSfAddress.{IsDigitalVoucherUser, SFAddress, SFContact, UsableContactAddress}
 import com.gu.sf_contact_merge.getsfcontacts.GetSfAddress.SFAddressFields._
+import com.gu.sf_contact_merge.getsfcontacts.GetSfAddress.{IsDigitalVoucherUser, SFAddress, SFContact, UsableContactAddress}
 import com.gu.test.EffectsTest
 import com.gu.util.config.{LoadConfigModule, Stage}
 import org.scalatest.{FlatSpec, Matchers}
@@ -20,8 +20,8 @@ class GetSfAddressEffectsTest extends FlatSpec with Matchers {
     val actual = for {
       sfConfig <- LoadConfigModule(Stage("DEV"), GetFromS3.fetchString)[SFAuthConfig]
       response = RawEffects.response
-      sfAuth <- SalesforceAuthenticate.doAuth(response, sfConfig).toDisjunction
-      get = SalesforceAuthenticate.get(response, sfAuth)
+      sfAuth <- SalesforceClient(response, sfConfig).value.toDisjunction
+      get = sfAuth.wrap(JsonHttp.get)
       getSfAddress = GetSfAddress(get)
       address <- getSfAddress.apply(testContact).value.toDisjunction
     } yield address