public async Task PostActionResult_ReturnsNewlyCreatedHash()
{
// Arrange
var userCredential = new UserCredential()
{
Login = "******",
Password = "******"
};
string key = $"{userCredential.Login}+{userCredential.Password}";
string hashValue = "65c884f742c8591808a121a828bc09f8";
var hashFuncClient = new Mock <IHashFuncClient>();
hashFuncClient.Setup(x => x.GetHash(key)).ReturnsAsync(hashValue);
var logger = new Mock <ILogger <HashController> >();
var controller = new HashController(hashFuncClient.Object, logger.Object);
// Act
var result = await controller.Post(userCredential);
// Assert
Assert.IsNotNull(result);
Assert.IsInstanceOf <OkObjectResult>(result);
var resultOk = (OkObjectResult)result;
Assert.IsNotNull(resultOk.Value);
Assert.IsInstanceOf <HashResponse>(resultOk.Value);
var resp = (HashResponse)resultOk.Value;
Assert.AreEqual(resp.hash_value, hashValue);
}
public RecruitmentTests()
{
// prepare mock httpclient
var mockHttpMessageHandler = new Mock <HttpMessageHandler>();
HashValue hashValue = new HashValue();
hashValue.hash_value = "4ED9407630EB1000C0F6B63842DEFA7D";
mockHttpMessageHandler.Protected()
.Setup <Task <HttpResponseMessage> >("SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(hashValue))
});
var client = new HttpClient(mockHttpMessageHandler.Object);
client.BaseAddress = new Uri("https://alternis.azurewebsites.net/api/CalcHash?code=5Fo6KFASKuXSHN5TwZOhlX9QoIk/bZn5mNANuhG7KQX4Rx5NaQat8g==");
_httpClientFactoryMock.Setup(_ => _.CreateClient(It.IsAny <string>())).Returns(client);
// prepare mock config
_configMock.SetupGet(m => m[It.Is <string>(s => s == "functionUrl")]).Returns("https://alternis.azurewebsites.net/api/CalcHash");
_configMock.SetupGet(m => m[It.Is <string>(s => s == "functionCode")]).Returns("5Fo6KFASKuXSHN5TwZOhlX9QoIk/bZn5mNANuhG7KQX4Rx5NaQat8g==");
//
_hashController = new HashController(_loggerMock.Object, _configMock.Object, _httpClientFactoryMock.Object);
}
public void post()
{
HashController sct = new HashController(fastdb);
var dt = new Dictionary<string, object>();
dt.Add("key1",new testmodel { i = 1, s = "yuyang" });
dt.Add("key2", new testmodel { i = 1, s = "yuyang" });
sct.Post("key", Newtonsoft.Json.JsonConvert.SerializeObject(dt));
}
public async Task Call_Hash_service_with_correct_credentials(
Mock <ILogger <HashController> > logger,
Mock <IHashService> hashServiceMock,
Credentials credentials)
{
var sut = new HashController(logger.Object, hashServiceMock.Object);
await sut.GetHash(credentials);
hashServiceMock.Verify(hashService => hashService.GetHash(credentials), Times.Once);
}
public async void PostTest()
{
var loginContract = new LoginContract {
Login = "******", Password = "******"
};
var loginHashContract = new LoginHashContract {
HashValue = "hashhashhashhash"
};
var mockFactory = new Mock <IHttpClientFactory>();
var handlerMock = new Mock <HttpMessageHandler>();
var response = new HttpResponseMessage
{
StatusCode = HttpStatusCode.OK,
Content = new StringContent(JsonConvert.SerializeObject(loginHashContract), Encoding.UTF8, "application/json"),
};
handlerMock
.Protected()
.Setup <Task <HttpResponseMessage> >(
"SendAsync",
ItExpr.IsAny <HttpRequestMessage>(),
ItExpr.IsAny <CancellationToken>())
.ReturnsAsync(response);
var httpClient = new HttpClient(handlerMock.Object);
mockFactory.Setup(_ => _.CreateClient(It.IsAny <string>())).Returns(httpClient);
Settings app = new Settings()
{
ApiUrls = new ApiUrls()
{
CalculateMD5 = "http://test"
}
};
var mockOptions = new Mock <IOptions <Settings> >();
// We need to set the Value of IOptions to be the SampleOptions Class
mockOptions.Setup(ap => ap.Value).Returns(app);
var hashController = new HashController(mockFactory.Object, mockOptions.Object);
var result = await hashController.PostAsync(loginContract);
var actual = JsonConvert.SerializeObject(((OkObjectResult)result).Value);
var expected = JsonConvert.SerializeObject(loginHashContract);
Assert.Equal(expected, actual);
}
public PersonagemRepositorio(IConfiguration configuracao)
{
cliente.DefaultRequestHeaders.Accept.Clear();
cliente.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
ts = DateTime.Now.Ticks.ToString();
chavePublica = configuracao.GetSection("MarvelComicsAPI:PublicKey").Value;
chavePrivada = configuracao.GetSection("MarvelComicsAPI:PrivateKey").Value;
var hashController = new HashController();
hash = hashController.GerarHash(ts, chavePublica, chavePrivada);
}
public async Task Return_hash_for_correct_credentials(
Mock <ILogger <HashController> > logger,
Mock <IHashService> hashServiceMock,
Credentials credentials,
string hash)
{
hashServiceMock.Setup(hashService => hashService.GetHash(credentials))
.ReturnsAsync(hash);
var sut = new HashController(logger.Object, hashServiceMock.Object);
var response = await sut.GetHash(credentials) as OkObjectResult;
response.ShouldNotBeNull();
}
private async void HashButton_ClickAsync(object sender, RoutedEventArgs e)
{
// StorageFile file = null;
// GetFile((chosenFile) => file = chosenFile);
StorageFile file = await GetFile();
byte[] rez = await GetBytesFromFile(file);
HashController controller = new HashController(new HashModel(SHA256.Create()), new HashView());
controller.SetBasedOnString(chosenAlgorithmName);
controller.UpdateView(rez, (result) =>
{
StringBuilder builder = new StringBuilder();
for (int i = 0; i < result.Length; i++)
{
builder.Append(result[i].ToString("x2"));
}
ResultTextBlock.Text = builder.ToString();
// await new MessageDialog(builder.ToString()).ShowAsync();
});
}
public void Setup()
{
_mockJobEngine = new Mock <IJobEngine>();
_classUnderTest = new HashController(_mockJobEngine.Object);
}
public HashControllerTest()
{
_hashManager = new Mock <IHashManager>(MockBehavior.Strict);
_hashController = new HashController(_hashManager.Object);
}
