public void TestGetAndSetModelMerchantDetails()
{
var merchantDetails = new MerchantDetails
{
CustomField1 = "",
CustomField2 = "",
CustomField3 = "",
CustomField4 = "",
CustomField5 = "",
CustomField6 = "",
CustomField7 = "",
CustomField8 = "",
CustomField9 = "",
CustomField10 = "",
CustomField11 = "",
CustomField12 = "",
CustomField13 = "",
CustomField14 = "",
CustomField15 = ""
};
var paymentRequest = new PaymentRequest(merchantInfo, sessionToken, currency, amount, paymentOptionCard)
{
MerchantDetails = merchantDetails
};
var paymentResponse = requestExecutor.Payment(paymentRequest).GetAwaiter().GetResult();
Assert.IsNotNull(paymentResponse);
Assert.IsEmpty(paymentResponse.Reason);
Assert.AreEqual(ResponseStatus.Success, paymentResponse.Status);
}
public async Task <Merchantdata> GetMerchantSettings(string SettingName)
{
try
{
var app = Application.Current as App;
Dictionary <string, object> payload = new Dictionary <string, object>();
payload.Add("access_key", app.SecurityAccessKey);
payload.Add("phone_number", app.UserPhoneNumber);
payload.Add("merchant_id", app.Merchantid);
payload.Add("setting_name", SettingName);
MerchantDetails robject = await this.Post <MerchantDetails>(this.getMerchantUrl("MerchantAppSettingDetails"), payload, null);
if (robject.status.ToLower() == "success")
{
return(robject.data.merchantdata);
}
else
{
return(null);
}
}
catch (Exception e)
{
try
{
DependencyService.Get <IToastMessage>().LongTime("Error CSD03:Something went wrong. Plese try again. ");
}
catch { }
return(null);
}
}
/// <summary>
/// This will save the merchants details in the database.
/// </summary>
/// <param name="id">The id.</param>
/// <returns> The Connectionstring </returns>
public static void SaveMerchantDetails(MerchantDetails merchantDetails)
{
using (IDbConnection cnn = new SQLiteConnection(LoadConnectionString()))
{
cnn.Execute("INSERT OR REPLACE INTO Merchants (Id, Name, CardNumber, Cvv) VALUES (@Id, @Name, @CardNumber, @Cvv)", merchantDetails);
}
}
public async Task <Merchantdata> GetMerchantSettings(string SettingName)
{
try
{
var app = App.Current as App;
Dictionary <string, object> payload = new Dictionary <string, object>();
payload.Add("access_key", app.SecurityAccessKey);
payload.Add("phone_number", app.UserPhoneNumber);
payload.Add("merchant_id", app.Merchantid);
payload.Add("setting_name", SettingName);
MerchantDetails robject = await this.Post <MerchantDetails>(this.getMerchantUrl("MerchantAppSettingDetails"), payload, null);
if (robject.status.ToLower() == "success")
{
return(robject.data.merchantdata);
}
else
{
return(null);
}
}
catch (Exception e)
{
await Application.Current.MainPage.DisplayAlert("Error", e.Message, "ok");
return(null);
}
}
public BankPaymentRequest(CardDetails cardDetails, MerchantDetails merchantDetails, decimal amount, string correlationId)
{
base.CorrelationId = correlationId;
Amount = amount;
CardDetails = cardDetails;
MerchantDetails = merchantDetails;
}
/// <summary>
/// Maps to models to bank request payload.
/// </summary>
/// <returns>
/// The <see cref="GetPaymentDetailsResponse" />.
/// </returns>
public BankRequestPayload Map(ProcessPaymentPayload payload, MerchantDetails merchantDetails, bool isPayout)
{
this.Amount = payload.Amount;
this.Currency = payload.Currency;
this.Reference = payload.Reference;
this.ExpiryDate = payload.ExpiryDate;
// set recipeint and sender depending on whether money is sent or received from merchant.
if (isPayout)
{
this.RecipientName = payload.Name;
this.RecipientCardNumber = payload.CardNumber;
this.RecipientCvv = payload.Cvv;
this.SenderName = merchantDetails.Name;
this.SenderCardNumber = merchantDetails.CardNumber;
this.SenderCvv = merchantDetails.Cvv;
}
else
{
this.RecipientName = merchantDetails.Name;
this.RecipientCardNumber = merchantDetails.CardNumber;
this.RecipientCvv = merchantDetails.Cvv;
this.SenderName = payload.Name;
this.SenderCvv = payload.Cvv;
this.SenderCardNumber = payload.CardNumber;
}
return(this);
}
public async Task RunAsync()
{
//string startdate = GeneralHelper.ResetTimeToStartOfDay(new DateTime(2017, 01, 25)).ToString("MM/dd/yyyy HH:mm:ss");
//string enddate = GeneralHelper.ResetTimeToStartOfDay(new DateTime(2017, 01, 26)).ToString("MM/dd/yyyy HH:mm:ss");
try
{
TokenDetails objTokenDetails = new TokenDetails();
MerchantDetails objMerchantDetails = new MerchantDetails();
Orders objOrders = new Orders();
MenuItems objMenuItems = new MenuItems();
EmployeeDetails objEmployeeDetails = new EmployeeDetails();
AuthenticationMethodResultModel result = await objTokenDetails.GetTalechAPI_Token();
LogHelper.Log("Access token:" + result.access_token + " Expires in:" + result.expires_in + " token_type:" + result.token_type);
Token.securityToken = result.access_token;
List <MerchantIdentification_StoreName> lstAllMerchantStoreInformation = await objMerchantDetails.GetAllMerchantStoreDetails();
LogHelper.Log("Merchant Store Count: " + lstAllMerchantStoreInformation.Count() + " Time: " + DateTime.Now);
await objMenuItems.GetMenuItemsByCriteria(lstAllMerchantStoreInformation);
//await objMenuItems.GetMenuUpdatesByCriteria(lstAllMerchantStoreInformation);
//LogHelper.Log("Menu Item and Category method completed. Count: " + lstAllMenuResultModel.Count() + " Time: " + DateTime.Now);
List <MerchantIdentification_StoreName> lstAllMerchantStoreInformationawait = await objEmployeeDetails.GetEmployeeByCriteria(lstAllMerchantStoreInformation);
LogHelper.Log("Get Employee list method completed. Time: " + DateTime.Now);
//tustin
//irvine
//euclid
//huntington beach
//cypress,fountain valley,alhambra,artesia,chino hills,westminster,tustin,irvine,euclid,huntington beach,costa mesa
lstAllMerchantStoreInformation = lstAllMerchantStoreInformation.
Where(s => s.merchantStoreName.ToLower() == "tustin").ToList();
string startdate = GeneralHelper.ResetTimeToStartOfDay(new DateTime(2018, 01, 25)).ToString("MM/dd/yyyy HH:mm:ss");
string enddate = GeneralHelper.ResetTimeToStartOfDay(new DateTime(2018, 01, 26)).ToString("MM/dd/yyyy HH:mm:ss");
await objOrders.GetOrderHistoryByCriteriaTestNew(lstAllMerchantStoreInformation, startdate, enddate);
//await GetOrderHistoryByCriteriaTest(lstAllMerchantStoreInformation, startdate, enddate);
//await GetOrderHistoryByCriteria(lstAllMerchantStoreInformation, startdate, enddate);
LogHelper.Log("GetOrderHistoryByCriteriaTestNew method completed for Start Date: " + startdate + " End Date: " + enddate + " Time: " + DateTime.Now);
//await GetOrderDetailsByOrderID(lstAllMerchantStoreInformation);
//await LogOff(lstAllMerchantStoreInformation);
//await DownloadStoreRevenueReport(lstAllMerchantStoreInformation,startdate,enddate);
//LogHelper.Log("DownloadStoreRevenueReport method completed for Start Date: " + startdate + " End Date: " + enddate + " Time: " + DateTime.Now);
// Console.WriteLine("File saved successfully");
}
catch (Exception ex)
{
LogHelper.Log("Erro in Run Async method. Error: " + ex.Message);
}
}
public void MutateTwitterLink(MerchantDetails merchantDetails)
{
if (merchantDetails.Values.TryGetValue("twitter", out var item))
{
merchantDetails.UpsertValue("twitter").Value = Regex.Replace(item.Value, @"((https?:\/\/)?(www.)?twitter.com\/?)|(@)", "").Trim('/');
}
}
public static void TestSetMerchantDetails()
{
try
{
SetupAppsettingsConfiguration();
// set merchant details
var merchantDetails = new MerchantDetails()
{
Id = testId,
Name = "Test",
CardNumber = "12345",
Cvv = "1"
};
ConnectionHelper.SaveMerchantDetails(merchantDetails);
// get merchant details
var result = ConnectionHelper.GetMerchantById(testId);
Assert.AreEqual(testId, result.Id);
Assert.AreEqual("Test", result.Name);
Assert.AreEqual("12345", result.CardNumber);
Assert.AreEqual("1", result.Cvv);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
throw;
}
finally
{
ConnectionHelper.DeleteMerchantById(testId);
}
}
public async Task <ActionResult> SaveBusnLocationGeneralInfo(MerchantDetails merch)//SaveDealersGeneralInfo
{
merch.UserID = GetUserId;
var data = await MechSignUpService.SaveBusnLocationGeneralInfo(merch);
return(Json(new { result = data, BusnLoc = data.returnValue.BusnLocation, EntityId = data.returnValue.EntityId }, JsonRequestBehavior.AllowGet));
}
public void MutateFacebookLink(MerchantDetails merchantDetails)
{
if (merchantDetails.Values.TryGetValue("facebook", out var item))
{
merchantDetails.UpsertValue("facebook").Value = Regex.Replace(item.Value, @"(https?:\/\/)?(www.)?facebook.com\/?", "").Trim('/');
}
}
public bool ExtractDetailsFromTitle(string title, MerchantDetails merchantDetails)
{
// RegEx pattern to match strings inside quotes (including escaped quotes) taken from
// https://stackoverflow.com/a/171499
var regex = new Regex(@"([""'])(?:(?=(\\?))\2.)*?\1", RegexOptions.IgnoreCase);
var matches = regex.Matches(title);
if (matches.Count != 2)
{
// Ensure there are only two matches - otherwise the title is in an unknown format
return(false);
}
// Ensure both matches were successful
if (!matches[0].Success && !matches[1].Success)
{
return(false);
}
merchantDetails.UpsertValue("name").Value = matches[0].Value.Trim('\'');
merchantDetails.UpsertValue("category").Value = matches[1].Value.Trim('\'');
Log.Debug("Extracted \"{name}\" and \"{category}\" from \"{title}\"", merchantDetails.Values["name"].Value, merchantDetails.Values["category"].Value, title);
return(true);
}
private void MapYmlKeyToDetailsWithSchema(MerchantDetails merchantDetails, MappingSchemaItem baseSchemaItem, string schemaXPath, string value)
{
var key = schemaXPath;
// If the key isn't in the schema, this isn't a valid field and can be ignored
// The exception to this is the 'category' key, which isn't included in the schema document
// TODO: Announce invalid fields
if (baseSchemaItem.Mapping.TryGetValue(key, out var schemaItem))
{
switch (schemaItem)
{
case KeyValueSchemaItem kvItem: {
var merchantDetailsItem = merchantDetails.UpsertValue(key);
merchantDetailsItem.SchemaItem = schemaItem;
merchantDetailsItem.Value = value;
}
break;
}
}
if (key == "category")
{
var merchantDetailsItem = merchantDetails.UpsertValue(key);
merchantDetailsItem.Value = value.Trim('\'').Trim('\"');
}
}
public async Task ItShouldBeGivenAnHttpsUrlAndTestTheHttpsVersionAndDoNothing()
{
var httpsUrlVariant = "https://google.com";
var merchantDetails = new MerchantDetails()
{
Values =
{
{ "url", new MerchantDetailsItem()
{
Value = httpsUrlVariant
} }
}
};
var networkService = new Mock <INetworkService>();
networkService.Setup(x => x.TestLiveliness(It.Is <string>(y => y == httpsUrlVariant))).ReturnsAsync(true);
var context = new Mock <IPipelineContext>();
context.SetupGet(x => x.MerchantDetails).Returns(merchantDetails);
var task = new DataMutationTask(networkService.Object);
var result = await task.Process(context.Object);
Assert.Equal(httpsUrlVariant, merchantDetails.Values["url"].Value);
}
public async Task ItShouldFailIfAllRequiredFieldsAreMissing()
{
var taskIdentifier = 5;
var merchantDetails = new MerchantDetails();
var repositoryContext = new Mock <IRepositoryContext>();
repositoryContext.Setup(x => x.EnumerateCategories()).Returns(Array.Empty <string>());
var context = new Mock <IPipelineContext>();
context.SetupGet(x => x.TaskIdentifier).Returns(taskIdentifier);
context.SetupGet(x => x.MerchantDetails).Returns(merchantDetails);
context.SetupGet(x => x.Data).Returns(new Dictionary <string, object>());
context.SetupGet(x => x.RepositoryContext).Returns(repositoryContext.Object);
context.SetupGet(x => x.Schema).Returns(schema);
var task = BuildTask();
var result = await task.Process(context.Object);
Assert.False(result.IsSuccess);
Assert.NotNull(result.Details);
}
public PipelineContext(int taskIdentifier, MerchantDetails merchantDetails, IRepositoryContext repositoryContext, ISchemaItem schema)
{
this.TaskIdentifier = taskIdentifier;
this.MerchantDetails = merchantDetails;
this.RepositoryContext = repositoryContext;
this.Schema = schema;
this.Data = new Dictionary <string, object>();
}
public async Task <Authorize3dResponse> Authorize3d(
string currency,
string amount,
PaymentOption paymentOption,
string relatedTransactionId,
List <Item> items = null,
string userTokenId = null,
string clientUniqueId = null,
string clientRequestId = null,
int?isRebilling = null,
AmountDetails amountDetails = null,
DeviceDetails deviceDetails = null,
CashierUserDetails userDetails = null,
UserAddress shippingAddress = null,
UserAddress billingAddress = null,
DynamicDescriptor dynamicDescriptor = null,
MerchantDetails merchantDetails = null,
Addendums addendums = null,
UrlDetails urlDetails = null,
string customSiteName = null,
string productId = null,
string customData = null,
string transactionType = null,
bool autoPayment3D = default,
string userId = null,
string rebillingType = null,
string authenticationTypeOnly = null,
SubMerchant subMerchant = null)
{
var request = new Authorize3dRequest(merchantInfo, sessionToken, currency, amount, paymentOption, relatedTransactionId)
{
Items = items,
UserTokenId = userTokenId,
ClientRequestId = clientRequestId,
ClientUniqueId = clientUniqueId,
IsRebilling = isRebilling,
AmountDetails = amountDetails,
DeviceDetails = deviceDetails,
UserDetails = userDetails,
ShippingAddress = shippingAddress,
BillingAddress = billingAddress,
DynamicDescriptor = dynamicDescriptor,
MerchantDetails = merchantDetails,
Addendums = addendums,
UrlDetails = urlDetails,
CustomSiteName = customSiteName,
ProductId = productId,
CustomData = customData,
TransactionType = transactionType,
AutoPayment3D = autoPayment3D,
UserId = userId,
RebillingType = rebillingType,
AuthenticationTypeOnly = authenticationTypeOnly,
SubMerchant = subMerchant
};
return(await safechargeRequestExecutor.Authorize3d(request));
}
public async Task ItShouldFailIfImageUrlEmptyAndTwitterHandleIsAvailableAndTwitterProfileUrlEmpty()
{
var taskIdentifier = 5;
var merchantDetails = new MerchantDetails()
{
Values =
{
{ "img", new MerchantDetailsItem()
{
Value = ""
} },
{ "name", new MerchantDetailsItem()
{
Value = "test"
} },
{ "category", new MerchantDetailsItem()
{
Value = "test"
} },
{ "url", new MerchantDetailsItem()
{
Value = "http://test"
} },
{ "bch", new MerchantDetailsItem()
{
Value = "Yes"
} },
{ "twitter", new MerchantDetailsItem()
{
Value = "test"
} },
}
};
var repositoryContext = new Mock <IRepositoryContext>();
repositoryContext.Setup(x => x.EnumerateCategories()).Returns(new string[] { "test" });
var context = new Mock <IPipelineContext>();
context.SetupGet(x => x.TaskIdentifier).Returns(taskIdentifier);
context.SetupGet(x => x.MerchantDetails).Returns(merchantDetails);
context.SetupGet(x => x.Data).Returns(new Dictionary <string, object>());
context.SetupGet(x => x.RepositoryContext).Returns(repositoryContext.Object);
context.SetupGet(x => x.Schema).Returns(schema);
var twitterService = new Mock <ITwitterService>();
twitterService.Setup(x => x.GetProfileImageUrl(It.Is <string>(y => y == merchantDetails.Values["twitter"].Value))).ReturnsAsync("");
var task = BuildTask(twitterService: twitterService.Object);
var result = await task.Process(context.Object);
Assert.Equal("", merchantDetails.Values["img"].Value);
Assert.False(result.IsSuccess);
}
public void ItShouldUpsertValue()
{
var merchantDetails = new MerchantDetails();
var result = merchantDetails.UpsertValue("test");
Assert.Single(merchantDetails.Values);
Assert.NotNull(result);
}
public IActionResult OnGet()
{
var merchantDetails = new MerchantDetails
{
MerchantName = "Atlas pvt",
MerchantAddress = "*****@*****.**"
};
ViewData["MerchantsName"] = new SelectList(_context.MerchantDetails, "MerchantId", "MerchantName");
ViewData["MerchantsEmail"] = new SelectList(_context.MerchantDetails, "MerchantId", "MerchantEmail");
return(Page());
}
public void ItShouldExtractMerchantDetailsFromIssueTitleSuccessfully()
{
var title = $"Add '{sampleMerchantName}' to the '{sampleCategory}' category";
var detailsLoader = new GithubIssueMerchantDetailsLoader(Mock.Of <IGitHubService>());
var merchantDetails = new MerchantDetails();
var result = detailsLoader.ExtractDetailsFromTitle(title, merchantDetails);
Assert.True(result);
Assert.Equal(sampleMerchantName, merchantDetails.Values["name"].Value);
Assert.Equal(sampleCategory, merchantDetails.Values["category"].Value);
}
public async Task MutateToSecureUrl(MerchantDetails merchantDetails)
{
var url = merchantDetails.Values["url"].Value;
if (url.StartsWith("http://"))
{
var secureUrl = url.Replace("http://", "https://");
if (await networkService.TestLiveliness(secureUrl))
{
merchantDetails.UpsertValue("url").Value = secureUrl;
}
}
}
public async Task ItShouldSucceedIfAllRequiredFieldsArePresent()
{
var taskIdentifier = 5;
var merchantDetails = new MerchantDetails()
{
Values =
{
{ "name", new MerchantDetailsItem()
{
Value = "test"
} },
{ "category", new MerchantDetailsItem()
{
Value = "category"
} },
{ "img", new MerchantDetailsItem()
{
Value = "https://image.url"
} },
{ "url", new MerchantDetailsItem()
{
Value = "https://merchant.url"
} },
{ "bch", new MerchantDetailsItem()
{
Value = "yes"
} },
}
};
var repositoryContext = new Mock <IRepositoryContext>();
repositoryContext.Setup(x => x.EnumerateCategories()).Returns(new string[] { merchantDetails.Values["category"].Value });
var context = new Mock <IPipelineContext>();
context.SetupGet(x => x.TaskIdentifier).Returns(taskIdentifier);
context.SetupGet(x => x.MerchantDetails).Returns(merchantDetails);
context.SetupGet(x => x.Data).Returns(new Dictionary <string, object>());
context.SetupGet(x => x.RepositoryContext).Returns(repositoryContext.Object);
context.SetupGet(x => x.Schema).Returns(schema);
var task = BuildTask();
var result = await task.Process(context.Object);
Assert.True(result.IsSuccess);
Assert.Null(result.Details);
}
public MechSignUpResponse()
{
merchGeneralInfo = new MA_GeneralInfo();
merchantDetail = new MerchantDetails();
merchChangeOwnerships = new List <MerchChangeOwnership>();
merchProductPrizes = new List <MerchProductPrize>();
busnLocTerminal = new BusnLocTerminal();
busnLocTerminals = new List <BusnLocTerminal>();
eService = new eService();
eServices = new List <eService>();
merchantDetails = new List <MerchantDetails>();
merchPostedTxnSearches = new List <MerchPostedTxnSearch>();
merchAgreements = new List <MA_GeneralInfo>();
merchChangeOwnership = new MerchChangeOwnership();
}
/// <summary>
/// This endpoint will set the merchants details.
/// </summary>
/// <param name="payload">The payload.</param>
/// <returns>
/// The <see cref="Task{IActionResult}" />.
/// </returns>
public static IActionResult SetMerchantDetails(SetMerchantDetailsPayload payload)
{
try
{
// save in database
MerchantDetails merchantDetails = new MerchantDetails().Map(payload);
ConnectionHelper.SaveMerchantDetails(merchantDetails);
// return response
return(new OkObjectResult(new SetMerchantDetailsResponse().Map(merchantDetails)));
}
catch (Exception ex)
{
return(new BadRequestObjectResult(ex.Message));
}
}
public async Task ItShouldSucceedIfMerchantDetailsNotShouldStopExecuting()
{
var merchantDetails = new MerchantDetails()
{
ShouldStopExecuting = false
};
var pipelineContext = new Mock <IPipelineContext>();
pipelineContext.SetupGet(x => x.MerchantDetails).Returns(merchantDetails);
var task = new TriggerCheckingTask();
var result = await task.Process(pipelineContext.Object);
Assert.False(result.IsSoftExit);
Assert.True(result.IsSuccess);
}
public async Task ItShouldAllowExecutingIfNoComments()
{
var schema = new MappingSchemaItem()
{
Mapping =
{
{ "websites", new SequenceSchemaItem()
{
Items =
{
new MappingSchemaItem()
{
Name = "Website",
Mapping =
{
{ "name", new KeyValueSchemaItem()
{
Type = "str", Required = true, Unique = true
} },
{ "url", new KeyValueSchemaItem()
{
Type = "str", Required = true, Unique = true
} }
}
}
}
} }
}
};
var issueComments = new List <IssueComment>();
var merchantDetails = new MerchantDetails();
var githubService = new Mock <IGitHubService>();
githubService.Setup(x => x.GetIssueComments(It.IsAny <RepositoryTarget>(), It.IsAny <int>())).ReturnsAsync(issueComments);
var detailsLoader = new GithubIssueMerchantDetailsLoader(githubService.Object);
await detailsLoader.ApplyIssueCommentCommandsToMerchantDetails(issueComments, schema, merchantDetails);
Assert.False(merchantDetails.ShouldStopExecuting);
}
public void ExtractFacebookHandleFromUrl(string facebookUrl)
{
var merchantDetails = new MerchantDetails()
{
Values =
{
{ "facebook", new MerchantDetailsItem()
{
Value = facebookUrl
} }
}
};
var task = new DataMutationTask(Mock.Of <INetworkService>());
task.MutateFacebookLink(merchantDetails);
Assert.Equal("testing", merchantDetails.Values["facebook"].Value);
}
public void ExtractTwitterHandleFromUrl(string twitterUrl)
{
var merchantDetails = new MerchantDetails()
{
Values =
{
{ "twitter", new MerchantDetailsItem()
{
Value = twitterUrl
} }
}
};
var task = new DataMutationTask(Mock.Of <INetworkService>());
task.MutateTwitterLink(merchantDetails);
Assert.Equal("testing", merchantDetails.Values["twitter"].Value);
}
public async Task ItShouldUseTwitterProfileImageIfImageUrlEmptyAndTwitterHandleIsAvailable()
{
var taskIdentifier = 5;
var twitterProfileImageUrl = "https://twitter.com/img";
var merchantDetails = new MerchantDetails()
{
Values =
{
{ "twitter", new MerchantDetailsItem()
{
Value = "test"
} },
{ "img", new MerchantDetailsItem()
{
Value = ""
} }
}
};
var repositoryContext = new Mock <IRepositoryContext>();
repositoryContext.Setup(x => x.EnumerateCategories()).Returns(Array.Empty <string>());
var context = new Mock <IPipelineContext>();
context.SetupGet(x => x.TaskIdentifier).Returns(taskIdentifier);
context.SetupGet(x => x.MerchantDetails).Returns(merchantDetails);
context.SetupGet(x => x.Data).Returns(new Dictionary <string, object>());
context.SetupGet(x => x.RepositoryContext).Returns(repositoryContext.Object);
context.SetupGet(x => x.Schema).Returns(schema);
var twitterService = new Mock <ITwitterService>();
twitterService.Setup(x => x.GetProfileImageUrl(It.Is <string>(y => y == merchantDetails.Values["twitter"].Value))).ReturnsAsync(twitterProfileImageUrl);
var task = BuildTask(twitterService: twitterService.Object);
var result = await task.Process(context.Object);
Assert.Equal(twitterProfileImageUrl, merchantDetails.Values["img"].Value);
}
