public bool TryBuild(out ClearableValue <T> result)
{
T value = Value;
string state = State;
if (string.IsNullOrEmpty(state) || string.Equals(state, Constants.Clearable_NoActionState, StringComparison.OrdinalIgnoreCase))
{
result = ClearableValue <T> .NoAction();
return(true);
}
if (string.Equals(state, Constants.Clearable_ClearState, StringComparison.OrdinalIgnoreCase))
{
result = ClearableValue <T> .Clear();
return(true);
}
if (string.Equals(state, Constants.Clearable_SetState, StringComparison.OrdinalIgnoreCase))
{
result = ClearableValue <T> .Set(value);
return(true);
}
result = default(ClearableValue <T>);
return(false);
}
public AndConstraint <ClearableValueAssertions <T> > NotBe(ClearableValue <T> expected, string because = "", params object[] becauseArgs)
{
Execute.Assertion
.ForCondition(!Subject.Equals(expected))
.BecauseOf(because, becauseArgs)
.FailWith("Expected {context:ClearableValue<T>} to be {0}{reason}, but found {1}.", expected, Subject);
return(new AndConstraint <ClearableValueAssertions <T> >(this));
}
public AndConstraint <NullableClearableValueAssertions <T> > Be(ClearableValue <T>?expected, string because = "", params object[] becauseArgs)
{
Execute.Assertion
.ForCondition(Subject == expected)
.BecauseOf(because, becauseArgs)
.FailWith("Expected {context:Address} to be {0}{reason}, but found {1}.", expected, Subject);
return(new AndConstraint <NullableClearableValueAssertions <T> >(this));
}
public void ParameterlessConstructor_ShouldBeNoAction()
{
// arrange
var sut = new ClearableValue <int>();
// act
// assert
sut.Should().BeNoActionVariant(because: "{0} is created using parameterless constructor and should be treated as 'noAction'", sut);
}
public void GenericSet_ShouldBeSet()
{
// arrange
var sut = ClearableValue.Set(Fixture.Create <int>());
// act
// assert
sut.Should().BeSetVariant(because: "{0} is created using generic Set<T>() method and should be treated as 'set'", sut);
}
public void ConstructorWithValue_ShouldBeSet()
{
// arrange
var sut = new ClearableValue <int>(Fixture.Create <int>());
// act
// assert
sut.Should().BeSetVariant(because: "{0} is created using constructor with value parameter and should be treated as 'set'", sut);
}
public void DomesticNoAction_ShouldBeNoAction()
{
// arrange
var sut = ClearableValue <int> .NoAction();
// act
// assert
sut.Should().BeNoActionVariant(because: "{0} is created using domestic static NoAction() method and should be treated as 'noAction'", sut);
}
public void GenericNoAction_ShouldBeNoAction()
{
// arrange
var sut = ClearableValue.NoAction(Fixture.Create <int>());
// act
// assert
sut.Should().BeNoActionVariant(because: "{0} is created using generic NoAction<T>() method and should be treated as 'noAction'", sut);
}
public void NoAction_ShouldNotCallMapper()
{
// arrange
var sut = ClearableValue <int> .NoAction();
// act
Action map = () => sut.Map <int>(_ => throw new InvalidOperationException());
// assert
map.Should().NotThrow(because: "mapping 'noAction' should not call mapper function");
}
public void Clear_ShouldMapToClear()
{
// arrange
var sut = ClearableValue <int> .Clear();
// act
var result = sut.Map(e => e.ToString());
// assert
result.Should().BeClearVariant();
}
public void NoAction_ShouldMapToNoAction()
{
// arrange
var sut = ClearableValue <int> .NoAction();
// act
var result = sut.Map(e => e.ToString());
// assert
result.Should().BeNoActionVariant();
}
private static IEnumerable <ClearableValue <string> > GetSerializeTestData()
{
yield return(ClearableValue <string> .NoAction());
yield return(ClearableValue <string> .Clear());
yield return(ClearableValue <string> .Set(null));
yield return(ClearableValue <string> .Set(string.Empty));
yield return(ClearableValue <string> .Set(System.Guid.NewGuid().ToString()));
}
public void SetOfDifferentValues_ShouldNotBeEqual()
{
// arrange
var set1 = ClearableValue <int> .Set(1);
var set2 = ClearableValue <int> .Set(2);
// act
// assert
set1.Equals(set2).Should().BeFalse();
set2.Equals(set1).Should().BeFalse();
}
public void NoActionAndDefaultClearableValue_ShouldBeEqual()
{
// arrange
var noAction = ClearableValue <int> .NoAction();
var @default = default(ClearableValue <int>);
// act
// assert
noAction.Equals(@default).Should().BeTrue();
@default.Equals(noAction).Should().BeTrue();
}
public void ClearAndSetOfDefaultValue_ShouldNotBeEqual()
{
// arrange
var clear = ClearableValue <int> .Clear();
var set = ClearableValue <int> .Set(default(int));
// act
// assert
clear.Equals(set).Should().BeFalse();
set.Equals(clear).Should().BeFalse();
}
public void SetOfSameValues_ShouldBeEqual()
{
// arrange
var set1 = ClearableValue <int> .Set(1);
var set2 = ClearableValue <int> .Set(1);
// act
// assert
set1.Equals(set2).Should().BeTrue();
set2.Equals(set1).Should().BeTrue();
}
public void NoActionAndClear_ShouldNotBeEqual()
{
// arrange
var noAction = ClearableValue <int> .NoAction();
var clear = ClearableValue <int> .Clear();
// act
// assert
noAction.Equals(clear).Should().BeFalse();
clear.Equals(noAction).Should().BeFalse();
}
public void NoActionAndSetOfDefaultValue_ShouldNotBeEqual()
{
// arrange
var noAction = ClearableValue <int> .NoAction();
var set = ClearableValue <int> .Set(default(int));
// act
// assert
noAction.Equals(set).Should().BeFalse();
set.Equals(noAction).Should().BeFalse();
}
public void Clear_ShouldMatch()
{
// arrange
var sut = ClearableValue <int> .Clear();
// act
var result = sut.Match(
set: _ => State.Set,
clear: () => State.Clear,
noAction: () => State.NoAction);
// assert
result.Should().Be(State.Clear);
}
public void Set_ShouldMatch()
{
// arrange
var sut = ClearableValue <int> .Set(Fixture.Create <int>());
// act
var result = sut.Match(
set: _ => State.Set,
clear: () => State.Clear,
noAction: () => State.NoAction);
// assert
result.Should().Be(State.Set);
}
public void Set_ShouldNotCallClearOrNoActionFunc()
{
// arrange
var sut = ClearableValue <int> .Set(Fixture.Create <int>());
// act
Action match = () => sut.Match(
set: _ => State.Set,
clear: () => throw new InvalidOperationException(),
noAction: () => throw new InvalidOperationException());
// assert
match.Should().NotThrow(because: "matching 'set' should not call neither 'clear' nor 'noAction' function");
}
public void NoAction_ShouldNotCallSetOrClearFunc()
{
// arrange
var sut = ClearableValue <int> .NoAction();
// act
Action match = () => sut.Match(
set: _ => throw new InvalidOperationException(),
clear: () => throw new InvalidOperationException(),
noAction: () => State.NoAction);
// assert
match.Should().NotThrow(because: "matching 'noAction' should not call neither 'set' nor 'clear' function");
}
public void Set_ShouldMapToSet()
{
// arrange
int originalValue = Fixture.Create <int>();
var sut = ClearableValue <int> .Set(originalValue);
Func <int, string> map = e => e.ToString();
string expectedValue = map(originalValue);
// act
var result = sut.Map(map);
// assert
result.Should().BeSetOf(expectedValue);
}
public void SerializeAndDeserialize_NoAction_ShouldBeIdempotent(ClearableValue <string> originalValue)
{
// arrange
var converter = new ClearableValueJsonConverter <string>();
// act
string serializedValue1 = JsonConvert.SerializeObject(originalValue, converter);
var deserializedValue1 = JsonConvert.DeserializeObject <ClearableValue <string> >(serializedValue1, converter);
string serializedValue2 = JsonConvert.SerializeObject(deserializedValue1, converter);
var deserializedValue2 = JsonConvert.DeserializeObject <ClearableValue <string> >(serializedValue2, converter);
// assert
deserializedValue1.Should().Be(originalValue);
deserializedValue2.Should().Be(originalValue);
deserializedValue2.Should().Be(deserializedValue1);
serializedValue2.Should().Be(serializedValue1);
}
public override void WriteJson(JsonWriter writer, ClearableValue <T> clearable, JsonSerializer serializer)
{
writer.WriteStartObject();
string state = clearable.Match(
set: _ => Constants.Clearable_SetState,
clear: () => Constants.Clearable_ClearState,
noAction: () => Constants.Clearable_NoActionState);
writer.WritePropertyName(Constants.StatePropertyName);
writer.WriteValue(state);
var(isSet, value) = clearable.Match(
set: e => (true, e),
clear: () => (false, default(T)),
noAction: () => (false, default(T)));
if (isSet)
{
writer.WritePropertyName(Constants.ValuePropertyName);
serializer.Serialize(writer, value);
}
writer.WriteEndObject();
}
public NullableClearableValueAssertions(ClearableValue <T>?subject) : base(subject)
{
}
public ClearableValueAssertions(ClearableValue <T>?subject)
{
Subject = subject;
}
public static ClearableValueAssertions <T> Should <T>(this ClearableValue <T> actualValue) => new ClearableValueAssertions <T>(actualValue);
public static NullableClearableValueAssertions <T> Should <T>(this ClearableValue <T>?actualValue) => new NullableClearableValueAssertions <T>(actualValue);
public override ClearableValue <T> ReadJson(JsonReader reader, Type objectType, ClearableValue <T> existingValue, bool hasExistingValue, JsonSerializer serializer)
{
var builder = new ClearableValueBuilder <T>();
if (reader.TokenType == JsonToken.StartObject)
{
while (reader.Read() && reader.TokenType != JsonToken.EndObject)
{
if (reader.TryReadPropertyAs(Constants.StatePropertyName, serializer, e => e.ReadAsString(), out var stateValue))
{
builder.State = stateValue;
}
else if (reader.TryDeserializeProperty(Constants.ValuePropertyName, serializer, out T valueObj))
{
builder.Value = valueObj;
}
}
}
if (!builder.TryBuild(out var clearable))
{
throw new InvalidOperationException($"Could not read {typeof(ClearableValue<T>)} from JSON.");
}
return(clearable);
}
