public void Constructor_Works()
{
var baseUri = new Uri("https://www.google.ch");
const string ActualResourcePathString = "Test";
Maybe <string> resourcePath = ActualResourcePathString;
const RestCallMethodType MethodType = RestCallMethodType.Get;
var security = RestSecurity.CreateAnonymous();
var headers = new RestHeaders(new List <RestHeader>());
var body = Maybe.CreateSome(RestCallBody.CreateApplicationJson(new object()));
var expectedFullUri = new Uri(baseUri, "/" + ActualResourcePathString);
var queryParameters = new QueryParameters(new List <QueryParameter>());
ConstructorTestBuilderFactory.Constructing <RestCall>()
.UsingDefaultConstructor()
.WithArgumentValues(baseUri, resourcePath, MethodType, security, headers, body, queryParameters)
.Maps()
.ToProperty(f => f.BaseUri).WithValue(baseUri)
.ToProperty(f => f.Body).WithValue(body)
.ToProperty(f => f.Headers).WithValue(headers)
.ToProperty(f => f.MethodType).WithValue(MethodType)
.ToProperty(f => f.ResourcePath).WithValue(resourcePath)
.ToProperty(f => f.Security).WithValue(security)
.ToProperty(f => f.AbsoluteUri).WithValue(expectedFullUri)
.BuildMaps()
.Assert();
}
public void Constructor_Works()
{
const string Host = "Host1234";
const int Port = 1234;
const string UserName = "******";
const string Password = "******";
ConstructorTestBuilderFactory.Constructing <ImapSettings>()
.UsingDefaultConstructor()
.WithArgumentValues(Host, Port, UserName, Password)
.Maps()
.ToProperty(f => f.Host).WithValue(Host)
.ToProperty(f => f.Password).WithValue(Password)
.ToProperty(f => f.Port).WithValue(Port)
.ToProperty(f => f.UserName).WithValue(UserName)
.BuildMaps()
.WithArgumentValues(string.Empty, Port, UserName, Password)
.Fails()
.WithArgumentValues(Host, 0, UserName, Password)
.Fails()
.WithArgumentValues(Host, Port, string.Empty, Password)
.Fails()
.WithArgumentValues(Host, Port, UserName, string.Empty)
.Fails()
.Assert();
}
public void Constructor_Works()
{
var targetLanguageCodes = new List <string> {
"en", "de"
};
var sourceLanguageCodes = new List <string> {
"zh", "fr"
};
var textParts = new List <string> {
"Hello"
};
ConstructorTestBuilderFactory.Constructing <TargetedSourceLanguageTranslationRequest>()
.UsingDefaultConstructor()
.WithArgumentValues(null, targetLanguageCodes, textParts).Fails()
.WithArgumentValues(sourceLanguageCodes, null, textParts).Fails()
.WithArgumentValues(sourceLanguageCodes, targetLanguageCodes, null).Fails()
.WithArgumentValues(sourceLanguageCodes, targetLanguageCodes, textParts)
.Maps()
.ToProperty(f => f.TargetLanguageCodes).WithValue(targetLanguageCodes)
.ToProperty(f => f.TextParts).WithValue(textParts)
.ToProperty(f => f.SourceLanguageCodes).WithValue(sourceLanguageCodes)
.BuildMaps()
.Assert();
}
public void Constructor_Works()
{
var emptyAddressList = new List <string>();
var toAddressList = new List <string> {
"*****@*****.**"
};
var fromAddressList = new List <string> {
"*****@*****.**"
};
const string Subject = "Test123";
const string EmptySubject = "";
const string Body = "Body1243";
ConstructorTestBuilderFactory.Constructing <Email>()
.UsingDefaultConstructor()
.WithArgumentValues(fromAddressList, toAddressList, Subject, Body)
.Maps()
.ToProperty(f => f.Body).WithValue(Body)
.ToProperty(f => f.Subject).WithValue(Subject)
.ToProperty(f => f.FromAddresses).WithValues(fromAddressList)
.ToProperty(f => f.ToAddresses).WithValues(toAddressList)
.BuildMaps()
.WithArgumentValues(fromAddressList, emptyAddressList, Subject, Body)
.Fails()
.WithArgumentValues(emptyAddressList, toAddressList, Subject, Body)
.Fails()
.WithArgumentValues(fromAddressList, toAddressList, EmptySubject, Body)
.Fails()
.WithArgumentValues(fromAddressList, toAddressList, null, Body)
.Fails()
.WithArgumentValues(fromAddressList, toAddressList, Subject, null)
.Succeeds()
.Assert();
}
public void Constructor_Works()
{
const string FromAddress = "*****@*****.**";
var emptyToAddressList = new List <string>();
var toAddressList = new List <string> {
"*****@*****.**"
};
const string Subject = "Subject";
var emailBody = new EmailBody("Tra", false);
ConstructorTestBuilderFactory.Constructing <Email>()
.UsingDefaultConstructor()
.WithArgumentValues(FromAddress, toAddressList, Subject, emailBody)
.Maps()
.ToProperty(f => f.Body).WithValue(emailBody)
.ToProperty(f => f.FromAddress).WithValue(FromAddress)
.ToProperty(f => f.Subject).WithValue(Subject)
.ToProperty(f => f.ToAddresses).WithValue(toAddressList)
.BuildMaps()
.WithArgumentValues(null, toAddressList, Subject, emailBody)
.Fails()
.WithArgumentValues(FromAddress, emptyToAddressList, Subject, emailBody)
.Fails()
.WithArgumentValues(FromAddress, toAddressList, null, emailBody)
.Fails()
.WithArgumentValues(FromAddress, toAddressList, Subject, string.Empty)
.Fails()
.Assert();
}
public void Constructor_WithQueryParameters_AddsQueryParametersToFullUri()
{
const string UriString = "https://www.google.ch";
var baseUri = new Uri(UriString);
const RestCallMethodType MethodType = RestCallMethodType.Get;
var security = RestSecurity.CreateAnonymous();
var headers = new RestHeaders(new List <RestHeader>());
var body = Maybe.CreateSome(RestCallBody.CreateApplicationJson(new object()));
var queryParameterList = new List <QueryParameter> {
new QueryParameter("Key1", "Value1", "Value2"), new QueryParameter("Key2", "Value3")
};
const string ExpectedUriString = UriString + "?Key1=Value1&Key1=Value2&Key2=Value3";
var expectedFullUri = new Uri(ExpectedUriString);
var queryParameters = new QueryParameters(queryParameterList);
ConstructorTestBuilderFactory.Constructing <RestCall>()
.UsingDefaultConstructor()
.WithArgumentValues(baseUri, Maybe.CreateNone <string>(), MethodType, security, headers, body, queryParameters)
.Maps()
.ToProperty(f => f.AbsoluteUri).WithValue(expectedFullUri)
.BuildMaps()
.Assert();
}
public void Constructor_Works()
{
ConstructorTestBuilderFactory.Constructing <QueryParameters>()
.UsingDefaultConstructor()
.WithArgumentValues(new List <QueryParameter>())
.Succeeds()
.WithArgumentValues(null)
.Fails()
.Assert();
}
public void WhenConfigShouldntFail_ButDoes_Throws()
{
Assert.Throws <AssertionException>(
() =>
{
ConstructorTestBuilderFactory.Constructing <Individual>()
.UsingConstructorWithParameters(typeof(string), typeof(string), typeof(DateTime?))
.WithArgumentValues(null, "Test2", new DateTime(1986, 12, 29)).Succeeds()
.Assert();
});
}
public void Constructor_Works()
{
var obj = new object();
ConstructorTestBuilderFactory.Constructing <ApplicationJsonBody>()
.UsingDefaultConstructor()
.WithArgumentValues(null)
.Fails()
.WithArgumentValues(obj)
.Maps()
.ToProperty(f => f.Payload).WithValue(obj)
.BuildMaps()
.Assert();
}
public void Constructor_Works()
{
const string StringContent = "StringContent";
const bool IsHtmlBody = true;
ConstructorTestBuilderFactory.Constructing <EmailBody>()
.UsingDefaultConstructor()
.WithArgumentValues(StringContent, IsHtmlBody)
.Maps()
.ToProperty(f => f.Content).WithValue(StringContent)
.ToProperty(f => f.IsHtmlBody).WithValue(IsHtmlBody)
.BuildMaps()
.Assert();
}
public void ComparingTwoNullValueCollections_DoesNotThrow()
{
Assert.DoesNotThrow(
() =>
{
ConstructorTestBuilderFactory.Constructing <Organisation>()
.UsingDefaultConstructor()
.WithArgumentValues(null)
.Maps()
.ToProperty(f => f.Addresses).WithValues(null)
.BuildMaps()
.Assert();
});
}
public void PassingEmptyCollection_MappingPropertyToEmptyCollection_DoesNotThrow()
{
Assert.DoesNotThrow(
() =>
{
ConstructorTestBuilderFactory.Constructing <Organisation>()
.UsingDefaultConstructor()
.WithArgumentValues(new List <string>())
.Maps()
.ToProperty(f => f.Addresses).WithValues(new List <string>())
.BuildMaps()
.Assert();
});
}
public void ConstructingWithParams_PassingNoValue_MapsToCollectionWithoutValues()
{
Assert.DoesNotThrow(
() =>
{
ConstructorTestBuilderFactory.Constructing <Address>()
.UsingDefaultConstructor()
.WithArgumentValues()
.Maps()
.ToProperty(f => f.Streets).WithValues(Array.Empty <string>())
.BuildMaps()
.Assert();
});
}
public void UsingDefaultConstructor_UsesConstructorWithLeastArguments()
{
const string FirstName = "Steven";
ConstructorTestBuilderFactory.Constructing <Individual>()
.UsingDefaultConstructor()
.WithArgumentValues(FirstName)
.Maps()
.ToProperty(f => f.BirthDate).WithValue(Individual.UnkownBirthdate)
.ToProperty(f => f.LastName).WithValue(Individual.UnkownLastname)
.ToProperty(f => f.FirstName).WithValue(FirstName)
.BuildMaps()
.Assert();
}
public void Constructor_Works()
{
ConstructorTestBuilderFactory.Constructing <RestHeader>()
.UsingDefaultConstructor()
.WithArgumentValues(null, "Value1")
.Fails()
.WithArgumentValues("Name1", string.Empty)
.Fails()
.WithArgumentValues("Name1", "Value1")
.Maps()
.ToProperty(f => f.Name).WithValue("Name1")
.ToProperty(f => f.Value).WithValue("Value1")
.BuildMaps()
.Assert();
}
public void UsingConstructorWith2Arguments_UsesConstructorWithTwoArguments()
{
const string FirstName = "Steven";
const string LastName = "Austin";
ConstructorTestBuilderFactory.Constructing <Individual>()
.UsingConstructorWithParameters(typeof(string), typeof(string))
.WithArgumentValues(FirstName, LastName)
.Maps()
.ToProperty(f => f.BirthDate).WithValue(Individual.UnkownBirthdate)
.ToProperty(f => f.LastName).WithValue(LastName)
.ToProperty(f => f.FirstName).WithValue(FirstName)
.BuildMaps()
.Assert();
}
public void Constructor_Works()
{
const string LanguageCode = "en";
const float AccuracyBetweenOneAndZero = 0.5F;
ConstructorTestBuilderFactory.Constructing <DetectedLanguage>()
.UsingDefaultConstructor()
.WithArgumentValues(null, AccuracyBetweenOneAndZero).Fails()
.WithArgumentValues(LanguageCode, AccuracyBetweenOneAndZero)
.Maps()
.ToProperty(f => f.AccuracyBetweenOneAndZero).WithValue(AccuracyBetweenOneAndZero)
.ToProperty(f => f.LanguageCode).WithValue(LanguageCode)
.BuildMaps()
.Assert();
}
public void ComparingTwoNullValues_DoesNotThrow()
{
Assert.DoesNotThrow(
() =>
{
ConstructorTestBuilderFactory.Constructing <Individual>()
.UsingConstructorWithParameters(typeof(string), typeof(string), typeof(DateTime?))
.WithArgumentValues("Matthias", "Müller", null)
.Maps()
.ToProperty(f => f.BirthDate).WithValue(null)
.ToProperty(f => f.FirstName).WithValue("Matthias")
.ToProperty(f => f.LastName).WithValue("Müller")
.BuildMaps()
.Assert();
});
}
public void Constructor_Works()
{
const string Text = "Hello";
const string TargetLanguageCode = "En";
ConstructorTestBuilderFactory.Constructing <Translation>()
.UsingDefaultConstructor()
.WithArgumentValues(null, Text).Fails()
.WithArgumentValues(TargetLanguageCode, null).Succeeds()
.WithArgumentValues(TargetLanguageCode, Text)
.Maps()
.ToProperty(f => f.TargetLanguageCode).WithValue(TargetLanguageCode)
.ToProperty(f => f.Text).WithValue(Text)
.BuildMaps()
.Assert();
}
public void Constructor_Works()
{
var entries = new List <RestHeader> {
new RestHeader("Name1", "Value1"), new RestHeader("Name2", "Value2"), new RestHeader("Name3", "Value3")
};
ConstructorTestBuilderFactory.Constructing <RestHeaders>()
.UsingDefaultConstructor()
.WithArgumentValues(null)
.Fails()
.WithArgumentValues(entries)
.Maps()
.ToProperty(f => f.Entries).WithValues(entries)
.BuildMaps()
.Assert();
}
public void Constructor_Works()
{
ConstructorTestBuilderFactory.Constructing <QueryParameter>()
.UsingDefaultConstructor()
.WithArgumentValues("Test", "Test1")
.Succeeds()
.WithArgumentValues("Test", "Test1", "Test2", "Test3")
.Succeeds()
.WithArgumentValues("Test")
.Succeeds()
.WithArgumentValues(null, "Test1")
.Fails()
.WithArgumentValues("Test", null)
.Fails()
.Assert();
}
public void Constructor_Works()
{
var dict = new Dictionary <string, string> {
{ "Key1", "Value1" }, { "Key2", "Value2" }, { "Key3", "Value3" }
};
ConstructorTestBuilderFactory.Constructing <ApplicationWwwFormUrlEncodedBody>()
.UsingDefaultConstructor()
.WithArgumentValues(null)
.Fails()
.WithArgumentValues(dict)
.Maps()
.ToProperty(f => f.Payload).WithValue(dict)
.BuildMaps()
.Assert();
}
public void Constructor_Works()
{
var translations = new List <Translation>
{
new Translation("Test", "en")
};
ConstructorTestBuilderFactory.Constructing <TargetedSourceLanguageTranslationResult>()
.UsingDefaultConstructor()
.WithArgumentValues(null).Fails()
.WithArgumentValues(translations).Succeeds()
.WithArgumentValues(translations).Maps()
.ToProperty(f => f.Translations).WithValue(translations)
.BuildMaps()
.Assert();
}
public void GenericConstructor_Works()
{
var actualObj = new object();
ConstructorTestBuilderFactory.Constructing <RestCallResult <object> >()
.UsingDefaultConstructor()
.WithArgumentValues(200, "Test1", null)
.Maps()
.ToProperty(f => f.Content).WithValue(null)
.BuildMaps()
.WithArgumentValues(200, "Test1", actualObj)
.Maps()
.ToProperty(f => f.Content).WithValue(actualObj)
.BuildMaps()
.Assert();
}
public void ConstructingWithParams_PassingOneValue_MapsToCollectionWithPassedValue()
{
var expectedStreets = new[]
{
"Fakestreet"
};
Assert.DoesNotThrow(
() =>
{
ConstructorTestBuilderFactory.Constructing <Address>()
.UsingDefaultConstructor()
.WithArgumentValues(expectedStreets.Single())
.Maps()
.ToProperty(f => f.Streets).WithValues(expectedStreets)
.BuildMaps()
.Assert();
});
}
public void ComparingConstructorNull_ToNotNullValueCollection_DoesThrow()
{
var expectedList = new List <string>();
var expexctedMessageEnding = FailingMessageFactory.CreateNotEqualMessage(expectedList, null);
Assert.That(
() =>
{
ConstructorTestBuilderFactory.Constructing <Organisation>()
.UsingDefaultConstructor()
.WithArgumentValues(null)
.Maps()
.ToProperty(f => f.Addresses).WithValues(expectedList)
.BuildMaps()
.Assert();
},
Throws.TypeOf <AssertionException>()
.And.Message.EndsWith(expexctedMessageEnding));
}
public void Constructor_Works()
{
var rootAssembly = typeof(ContainerConfigurationUnitTests).Assembly;
const string AssemblyPrefix = "Mmu.Mlh";
const bool InitializeAutoMapper = true;
ConstructorTestBuilderFactory.Constructing <ContainerConfiguration>()
.UsingDefaultConstructor()
.WithArgumentValues(null, null).Fails()
.WithArgumentValues(rootAssembly, null).Fails()
.WithArgumentValues(null, AssemblyPrefix).Fails()
.WithArgumentValues(rootAssembly, AssemblyPrefix, InitializeAutoMapper)
.Maps()
.ToProperty(f => f.AssemblyPrefix).WithValue(AssemblyPrefix)
.ToProperty(f => f.InitializeAutoMapper).WithValue(InitializeAutoMapper)
.ToProperty(f => f.RootAssembly).WithValue(rootAssembly)
.BuildMaps()
.Assert();
}
public void WithMappingToProperty_MappingBeingCorrect_Works()
{
const string FirstName = "Steven";
const string LastName = "Austin";
var birthdate = new DateTime(1964, 12, 18);
const string ExpectedFullName = FirstName + " " + LastName;
Assert.DoesNotThrow(
() =>
{
ConstructorTestBuilderFactory.Constructing <Individual>()
.UsingConstructorWithParameters(typeof(string), typeof(string), typeof(DateTime?))
.WithArgumentValues(FirstName, LastName, birthdate)
.Maps()
.ToProperty(f => f.FullName).WithValue(ExpectedFullName)
.ToProperty(f => f.BirthDate).WithValue(birthdate)
.BuildMaps()
.Assert();
});
}
public void WithValidConfig_DoesNotThrow()
{
const string FirstName = "Matthias";
Assert.DoesNotThrow(
() =>
{
ConstructorTestBuilderFactory.Constructing <Individual>()
.UsingConstructorWithParameters(typeof(string), typeof(string), typeof(DateTime?))
.WithArgumentValues(FirstName, null, null).Succeeds()
.WithArgumentValues(null, null, null).Fails()
.WithArgumentValues(FirstName, null, null)
.Maps()
.ToProperty(f => f.FirstName).WithValue(FirstName)
.ToProperty(f => f.FullName).WithValue(FirstName)
.ToProperty(f => f.BirthDate).WithValue(null)
.BuildMaps()
.Assert();
});
}
public void ComparingConstructorNull_ToNotNullValue_DoesThrow()
{
var expectedDate = new DateTime(1986, 12, 29);
var expectedMessageEnding = FailingMessageFactory.CreateNotEqualMessage(expectedDate, null);
Assert.That(
() =>
{
ConstructorTestBuilderFactory.Constructing <Individual>()
.UsingConstructorWithParameters(typeof(string), typeof(string), typeof(DateTime?))
.WithArgumentValues("Matthias", "Müller", null)
.Maps()
.ToProperty(f => f.BirthDate).WithValue(expectedDate)
.ToProperty(f => f.FirstName).WithValue("Matthias")
.ToProperty(f => f.LastName).WithValue("Müller")
.BuildMaps()
.Assert();
},
Throws.TypeOf <AssertionException>()
.And.Message.EndsWith(expectedMessageEnding));
}
