public static void DemoNegativeCaseNoItems()
{
// We add fake responce for negative case in the begining
// of list (with highest priority)
applyProcessor.AddFirst(item =>
{
if (item.getType() != "Part" ||
item.getAction() != "get" ||
item.getAttribute("select") != "id" ||
item.getProperty("name") != "PRE-*")
{
return(null);
}
Item result = ItemHelper.CreateItem("Part", string.Empty);
result.loadAML(
"<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\">" +
"<SOAP-ENV:Body>" +
"<SOAP-ENV:Fault xmlns:af=\"http://www.aras.com/InnovatorFault\">" +
"<faultcode>0</faultcode>" +
"<faultstring>" +
"<![CDATA[No items of type Part found.]]>" +
"</faultstring>" +
"</SOAP-ENV:Fault>" +
"</SOAP-ENV:Body>" +
"</SOAP-ENV:Envelope>");
return(result);
});
Item actualResult = businessLogic.Run(null);
Assert.AreEqual(actualResult.getResult(), "0");
}
public static void DemoNegativeCaseError()
{
Item result = ItemHelper.CreateItem("Part", string.Empty);
// We add fake responce for negative case in the begining
// of list (with highest priority)
applyProcessor.AddFirst(item =>
{
if (item.getType() != "Part" ||
item.getAction() != "get" ||
item.getAttribute("select") != "id" ||
item.getProperty("name") != "PRE-*")
{
return(null);
}
result.loadAML(
"<SOAP-ENV:Envelope xmlns:SOAP-ENV=\"http://schemas.xmlsoap.org/soap/envelope/\">" +
"<SOAP-ENV:Body>" +
"<SOAP-ENV:Fault xmlns:af=\"http://www.aras.com/InnovatorFault\">" +
"<faultcode>SOAP-ENV:Server.PermissionsNoCanGetFoundException</faultcode>" +
"<faultstring>" +
"<![CDATA[Get access is denied for Part.]]>" +
"</faultstring>" +
"</SOAP-ENV:Fault>" +
"</SOAP-ENV:Body>" +
"</SOAP-ENV:Envelope>");
return(result);
});
Item error = Assert.Throws <TestedMethod.InnovatorItemException>(() => businessLogic.Run(null)).ErrorItem;
Assert.AreEqual(error, result);
}
public void Handle_WhenValidationContextDoesNotHaveRelationshipItems_ShouldThrowInvalidOperationException()
{
//arrange
var relationshipItems = new Dictionary <string, IEnumerable <Item> >()
{
{ TestRelationshipName, Array.Empty <Item>() },
};
var validationContext = new ValidationContext(relationshipItems)
{
CurrentGECO = ItemHelper.CreateItem(string.Empty, string.Empty),
RootItem = ItemHelper.CreateItem(string.Empty, string.Empty),
};
IRelationshipNameProvider relationshipNameProvider = Substitute.For <IRelationshipNameProvider>();
relationshipNameProvider.TabName.Returns("Another relationship name");
string[] availableClassifications = { "Release & Change/CAD Document" };
var testClass = new TestClass(nameof(TestClass), Substitute.For <IGECOProvider>(), relationshipNameProvider, availableClassifications, Array.Empty <string>());
//act
//assert
Assert.Throws <InvalidOperationException>(() => testClass.Handle(validationContext));
}
public void Run_WhenContextItemHasDifferentFlagValue_ShouldThrowItemException()
{
//arrange
const string expectedError = "The property gag_migration_edit_flag cannot be changed";
Item fakeContextItem = ItemHelper.CreateItem("CAD", string.Empty);
fakeContextItem.setProperty("gag_migration_edit_flag", "0");
fakeContextItem.setProperty("config_id", GenerateConfigId());
Item fakeLatestItem = ItemHelper.CreateItem("CAD", string.Empty);
fakeLatestItem.setProperty("gag_migration_edit_flag", "1");
fakeLatestItem.setProperty("config_id", GenerateConfigId());
IDataAccessLayer fakeDal = Substitute.For <IDataAccessLayer>();
fakeDal.ApplyItem(Arg.Any <Item>()).Returns(fakeLatestItem);
fakeDal.NewItem(Arg.Any <string>(), Arg.Any <string>()).Returns(ItemHelper.CreateItem("CAD", string.Empty));
var testClass = new TestClass(fakeDal);
//act
//assert
ItemException exception = Assert.Throws <ItemException>(() => testClass.Run(fakeContextItem));
string actualError = exception.Message;
Assert.AreEqual(actualError, expectedError);
}
public void Run_WhenLatestItemNotFound_ShouldReturnContextItem()
{
//arrange
Item fakeContextItem = ItemHelper.CreateItem("CAD", string.Empty);
fakeContextItem.setProperty("gag_migration_edit_flag", "1");
fakeContextItem.setProperty("config_id", GenerateConfigId());
fakeContextItem.setNewID();
Item errorItem = ItemHelper.CreateItem(string.Empty, string.Empty);
errorItem.loadAML(EmptyResult);
IDataAccessLayer fakeDal = Substitute.For <IDataAccessLayer>();
fakeDal.NewItem(Arg.Any <string>(), Arg.Any <string>()).Returns(ItemHelper.CreateItem("CAD", string.Empty));
fakeDal.ApplyItem(Arg.Any <Item>()).Returns(errorItem);
var testClass = new TestClass(fakeDal);
//act
Item actualItem = testClass.Run(fakeContextItem);
//assert
Assert.AreEqual(actualItem.getID(), fakeContextItem.getID());
}
public void Run_InvalidFlagValue_ShouldThrowItemException(string flagValue)
{
//arrange
const string expectedError = "Unknown flag value";
Item fakeContextItem = ItemHelper.CreateItem("GAG_GECO ChangeControlled", string.Empty);
Item fakeAffectedItem = ItemHelper.CreateItem("GAG_GrammerChangeControlled", "get");
fakeAffectedItem.setProperty("gag_migration_edit_flag", flagValue);
IDataAccessLayer fakeDal = Substitute.For <IDataAccessLayer>();
fakeDal.ApplyItem(Arg.Any <Item>()).Returns(fakeAffectedItem);
fakeDal.NewItem("GAG_GrammerChangeControlled", "get").Returns(fakeAffectedItem);
fakeDal.NewError(Arg.Any <string>()).Returns(ci =>
{
Item error = ItemHelper.CreateItem(string.Empty, string.Empty);
error.loadAML(string.Format(CultureInfo.CurrentCulture, ErrorResultTemplate, ci.ArgAt <string>(0)));
return(error);
});
var testClass = new TestClass(fakeDal);
//act
//assert
ItemException exception = Assert.Throws <ItemException>(() => testClass.Run(fakeContextItem));
string actualError = exception?.ErrorItem?.getErrorString();
Assert.AreEqual(actualError, expectedError);
}
public static void SetupEachTest()
{
// Before each test execution we reinitialize fake DAL and businessLogic
// so tests won't conflict between themselves
fakeDataAccessLayer = Substitute.For <TestedMethod.IDataAccessLayer>();
businessLogic = new TestedMethod.BusinessLogic(fakeDataAccessLayer);
innovator = ItemHelper.CreateInnovator();
fakeDataAccessLayer.NewItem(Arg.Any <string>(), Arg.Any <string>())
.Returns(@params => ItemHelper.CreateItem((string)@params[0], (string)@params[1]));
fakeDataAccessLayer.NewResult(Arg.Any <string>())
.Returns(@params => innovator.newResult((string)@params[0]));
// We use applyProcessor List to store fake AML responces
applyProcessor = InitializeApplyProcessor();
fakeDataAccessLayer.ApplyItem(Arg.Any <Item>())
.Returns(@params =>
{
Item paramItem = (Item)@params[0];
foreach (Func <Item, Item> processor in applyProcessor)
{
Item result = processor(paramItem);
if (result != null)
{
return(result);
}
}
return(null);
});
}
public void Handle_WhenStatesOfThreeRelationshipItemAreNotInAllowedStates_ShouldReturnCollectionWithThreeErrorMessages()
{
//arrange
var invalidStates = new[]
{
"15",
"1",
"30",
};
var allowedStates = new[]
{
"10",
"20",
};
int expectedErrorCounts = invalidStates.Length;
var items = invalidStates.Select(state =>
{
Item item = ItemHelper.CreateItem(TestType, string.Empty);
item.setProperty(StatePropertyKey, state);
return(item);
});
var relationshipItems = new Dictionary <string, IEnumerable <Item> >()
{
{ TestRelationshipName, items },
};
var validationContext = new ValidationContext(relationshipItems)
{
CurrentGECO = ItemHelper.CreateItem(string.Empty, string.Empty),
RootItem = ItemHelper.CreateItem(string.Empty, string.Empty),
};
IRelationshipNameProvider relationshipNameProvider = Substitute.For <IRelationshipNameProvider>();
relationshipNameProvider.TabName.Returns(TestRelationshipName);
var testClass = new TestClass(nameof(TestClass), relationshipNameProvider, allowedStates);
IReadOnlyCollection <ValidatorInfoModel> validatorInfo
= new[]
{
new ValidatorInfoModel
{
AllowedStates = allowedStates,
Name = testClass.Name,
Type = TestType,
},
};
StepHelper.ApplyFinalStep(testClass, validatorInfo);
//act
IList <string> result = testClass.Handle(validationContext).ToList();
//assert
Assert.AreEqual(expectedErrorCounts, result.Count);
}
public static void SetupEachTest()
{
fakeDataAccessLayer = Substitute.For <TestedMethod.IDataAccessLayer>();
innovator = ItemHelper.CreateInnovator();
fakeDataAccessLayer = Substitute.For <TestedMethod.IDataAccessLayer>();
fakeDataAccessLayer.NewItem(Arg.Any <string>(), Arg.Any <string>())
.Returns(@params => ItemHelper.CreateItem((string)@params[0], (string)@params[1]));
fakeDataAccessLayer.NewError(Arg.Any <string>())
.Returns(@params => innovator.newError((string)@params[0]));
}
public void Run_WhenClassificationIsMechanical_ShouldSetExpectedClassificationFilter(string classification, string expectedClassificationFilter)
{
//arrange
Item fakeCad = ItemHelper.CreateItem("CAD", string.Empty);
fakeCad.setProperty("classification", classification);
//act
Item result = TestClass.Run(fakeCad);
string classificationFilter = result.getProperty("gag_classification_filter");
//assert
Assert.AreEqual(expectedClassificationFilter, classificationFilter);
}
public void Run_WhenClassificationIs_ShouldReturnExpectedIcon(string classification, string expectedIcon)
{
//arrange
Item fakePart = ItemHelper.CreateItem(string.Empty, string.Empty);
fakePart.setProperty("classification", classification);
//act
fakePart = TestClass.Run(fakePart);
//assert
string actualIcon = fakePart.getProperty("gag_icon");
Assert.AreEqual(expectedIcon, actualIcon);
}
public void Run_AnyMigrationFlagValue_ShouldSetMigrationFlagValueAs1(string initialFlagValue)
{
//arrange
const string expectedFlagValue = "1";
Item fakeContextItem = ItemHelper.CreateItem("CAD", string.Empty);
fakeContextItem.setProperty("gag_migration_edit_flag", initialFlagValue);
//act
Item result = TestClass.Run(fakeContextItem);
//assert
string actualFlagValue = result.getProperty("gag_migration_edit_flag");
Assert.AreEqual(actualFlagValue, expectedFlagValue);
}
public void Handle_WhenNextStepIsDefined_ShouldCallNextStep()
{
//arrange
var ignoreStates = new[]
{
"10",
"20",
};
var tabItems = ignoreStates.Select(state =>
{
Item item = ItemHelper.CreateItem(string.Empty, string.Empty);
item.setProperty(StatePropertyKey, state);
return(item);
});
//arrange
var relationshipItems = new Dictionary <string, IEnumerable <Item> >()
{
{ TestRelationshipName, tabItems },
};
var validationContext = new ValidationContext(relationshipItems)
{
CurrentGECO = ItemHelper.CreateItem(string.Empty, string.Empty),
RootItem = ItemHelper.CreateItem(string.Empty, string.Empty),
};
Item anotherGECO = ItemHelper.CreateItem(string.Empty, string.Empty);
IRelationshipNameProvider relationshipNameProvider = Substitute.For <IRelationshipNameProvider>();
relationshipNameProvider.TabName.Returns(TestRelationshipName);
IGECOProvider gecoProvider = Substitute.For <IGECOProvider>();
gecoProvider.GetRelatedGECOs(anotherGECO);
IStep nextStep = Substitute.For <IStep>();
string[] availableClassifications = { "Release & Change/CAD Document" };
var testClass = new TestClass(nameof(TestClass), gecoProvider, relationshipNameProvider, availableClassifications, ignoreStates);
testClass.SetNext(nextStep);
//act
testClass.Handle(validationContext);
//assert
nextStep.Received(1).Handle(Arg.Any <ValidationContext>());
}
public void Run_WhenClassificationIsNotMechanical_ShouldClearProperty(string cleanableProperty)
{
//arrange
const string classification = "Test classification";
string expectedClassificationFilter = string.Empty;
Item fakeCad = ItemHelper.CreateItem("CAD", string.Empty);
fakeCad.setProperty("classification", classification);
//act
Item result = TestClass.Run(fakeCad);
string classificationFilter = result.getProperty(cleanableProperty);
//assert
Assert.AreEqual(expectedClassificationFilter, classificationFilter);
}
public void Handle_WhenNextStepIsDefined_ShouldCallNextStep()
{
//arrange
var allowedStates = new[]
{
"10",
"20",
};
var items = allowedStates.Select(state =>
{
Item item = ItemHelper.CreateItem("Test item", string.Empty);
item.setProperty(StatePropertyKey, state);
return(item);
});
var relationshipItems = new Dictionary <string, IEnumerable <Item> >()
{
{ TestRelationshipName, items },
};
var validationContext = new ValidationContext(relationshipItems)
{
CurrentGECO = ItemHelper.CreateItem(string.Empty, string.Empty),
RootItem = ItemHelper.CreateItem(string.Empty, string.Empty),
};
IRelationshipNameProvider relationshipNameProvider = Substitute.For <IRelationshipNameProvider>();
relationshipNameProvider.TabName.Returns(TestRelationshipName);
IStep nextStep = Substitute.For <IStep>();
var testClass = new TestClass(nameof(TestClass), relationshipNameProvider, allowedStates);
testClass.SetNext(nextStep);
//act
testClass.Handle(validationContext);
//assert
nextStep.Received(1).Handle(Arg.Any <ValidationContext>());
}
public static void DemoPositiveCaseThreeItem()
{
// We add fake responce for positive case in the end of list
applyProcessor.AddLast(item =>
{
if (item.getType() != "Part" ||
item.getAction() != "get" ||
item.getAttribute("select") != "id" ||
item.getProperty("name") != "PRE-*")
{
return(null);
}
Item result = ItemHelper.CreateItem("Part", string.Empty);
result.appendItem(ItemHelper.CreateItem("Part", string.Empty));
result.appendItem(ItemHelper.CreateItem("Part", string.Empty));
return(result);
});
Item actualResult = businessLogic.Run(null);
Assert.AreEqual(actualResult.getResult(), "3");
}
public static void DemoPositiveCaseOneItem()
{
// We add fake responce for positive case in the end of list.
// It is also possible to add several fake responses
applyProcessor.AddLast(item =>
{
if (item.getType() != "Part" ||
item.getAction() != "get" ||
item.getAttribute("select") != "id" ||
item.getProperty("name") != "PRE-*")
{
return(null);
}
Item result = ItemHelper.CreateItem("Part", string.Empty);
return(result);
});
// In method we don't use context item so we can pass any parameter
Item actualResult = businessLogic.Run(null);
Assert.AreEqual(actualResult.getResult(), "1");
}
public void Run_MigrationFlagIs1_ShouldReturnContextItem()
{
//arrange
Item fakeContextItem = ItemHelper.CreateItem("GAG_GECO ChangeControlled", string.Empty);
fakeContextItem.setNewID();
Item fakeAffectedItem = ItemHelper.CreateItem("GAG_GrammerChangeControlled", "get");
fakeAffectedItem.setProperty("gag_migration_edit_flag", "1");
IDataAccessLayer fakeDal = Substitute.For <IDataAccessLayer>();
fakeDal.ApplyItem(Arg.Any <Item>()).Returns(fakeAffectedItem);
fakeDal.NewItem("GAG_GrammerChangeControlled", "get").Returns(fakeAffectedItem);
var testClass = new TestClass(fakeDal);
//act
Item result = testClass.Run(fakeContextItem);
//assert
Assert.AreEqual(result.getID(), fakeContextItem.getID());
}
public void Handle_WhenRelationshipItemsOnCurrentGECOWithNotAllowedState_ShouldReturnErrorCollection()
{
//arrange
var allowedStates = new[]
{
"10",
};
Item affectedItem = ItemHelper.CreateItem(string.Empty, string.Empty);
affectedItem.setProperty("gag_action", "Release");
Item item = ItemHelper.CreateItem(TestType, string.Empty);
item.setProperty(StatePropertyKey, "invalid state");
var relationshipItems = new Dictionary <string, IEnumerable <Item> >()
{
{ TestRelationshipName, new [] { item } },
};
Item currentGECO = ItemHelper.CreateItem(string.Empty, string.Empty);
currentGECO.setNewID();
var validationContext = new ValidationContext(relationshipItems)
{
CurrentGECO = currentGECO,
RootItem = ItemHelper.CreateItem(string.Empty, string.Empty),
};
int expectedErrorCounts = allowedStates.Length;
IRelationshipNameProvider relationshipNameProvider = Substitute.For <IRelationshipNameProvider>();
relationshipNameProvider.TabName.Returns(TestRelationshipName);
Item anotherGECO = ItemHelper.CreateItem(string.Empty, string.Empty);
anotherGECO.setNewID();
Item[] relatedItems = { anotherGECO };
IGECOProvider gecoProvider = Substitute.For <IGECOProvider>();
gecoProvider.GetRelatedGECOs(Arg.Any <Item>()).Returns(relatedItems);
gecoProvider.GetActualItems(Arg.Any <Item>(), Arg.Any <Item>()).Returns(relatedItems);
gecoProvider.GECOContainsItem(Arg.Any <Item>(), Arg.Any <string>()).Returns(true);
gecoProvider.FindAffectedItems(Arg.Any <Item>(), Arg.Any <string>()).Returns(new[] { affectedItem });
var testClass = new TestClass(nameof(TestClass), gecoProvider, relationshipNameProvider, allowedStates);
IReadOnlyCollection <ValidatorInfoModel> validatorInfo
= new[]
{
new ValidatorInfoModel
{
AllowedStates = allowedStates,
Name = testClass.Name,
Type = TestType,
},
};
StepHelper.ApplyFinalStep(testClass, validatorInfo);
//act
IList <string> result = testClass.Handle(validationContext).ToList();
//assert
Assert.AreEqual(expectedErrorCounts, result.Count);
}
public void Handle_WhenNextStepIsDefined_ShouldCallNextStep()
{
//arrange
var allowedStates = new[]
{
"10",
};
var allowedOtherGECOsStates = new[]
{
"10",
"25",
};
var tabItems = allowedStates.Select(state =>
{
Item item = ItemHelper.CreateItem(string.Empty, string.Empty);
item.setProperty(StatePropertyKey, state);
return(item);
});
var relationshipItems = new Dictionary <string, IEnumerable <Item> >()
{
{ TestRelationshipName, tabItems },
};
Item currentGECO = ItemHelper.CreateItem(string.Empty, string.Empty);
currentGECO.setNewID();
var validationContext = new ValidationContext(relationshipItems)
{
CurrentGECO = currentGECO,
RootItem = ItemHelper.CreateItem(string.Empty, string.Empty),
};
IRelationshipNameProvider relationshipNameProvider = Substitute.For <IRelationshipNameProvider>();
relationshipNameProvider.TabName.Returns(TestRelationshipName);
Item anotherGECO = ItemHelper.CreateItem(string.Empty, string.Empty);
anotherGECO.setNewID();
Item affectedItem = ItemHelper.CreateItem(string.Empty, string.Empty);
affectedItem.setProperty("gag_action", "Release");
IGECOProvider gecoProvider = Substitute.For <IGECOProvider>();
gecoProvider.GetRelatedGECOs(Arg.Any <Item>()).Returns(new[] { anotherGECO });
gecoProvider.GECOContainsItem(Arg.Any <Item>(), Arg.Any <string>()).Returns(false);
gecoProvider.FindAffectedItems(Arg.Any <Item>(), Arg.Any <string>()).Returns(new[] { affectedItem });
IStep nextStep = Substitute.For <IStep>();
var testClass = new TestClass(nameof(TestClass), gecoProvider, relationshipNameProvider, allowedStates);
testClass.SetNext(nextStep);
//act
testClass.Handle(validationContext);
//assert
nextStep.Received(1).Handle(Arg.Any <ValidationContext>());
}
public void Handle_WhenRelationshipItemsWithAllowedStatesContainsOnOtherActiveGECOsWithNotCadReleaseClassification_ShouldReturnCollectionWithMessages(string affectedItemAction)
{
//arrange
var states = new[]
{
"10",
"20",
};
var tabItems = states.Select(state =>
{
Item item = ItemHelper.CreateItem(TestType, string.Empty);
item.setProperty(StatePropertyKey, state);
return(item);
});
var relationshipItems = new Dictionary <string, IEnumerable <Item> >()
{
{ TestRelationshipName, tabItems },
};
Item currentGECO = ItemHelper.CreateItem(string.Empty, string.Empty);
currentGECO.setNewID();
var validationContext = new ValidationContext(relationshipItems)
{
CurrentGECO = currentGECO,
RootItem = ItemHelper.CreateItem(string.Empty, string.Empty),
};
Item affectedItem = ItemHelper.CreateItem(string.Empty, string.Empty);
affectedItem.setProperty("gag_action", affectedItemAction);
int expectedErrorCounts = states.Length;
IRelationshipNameProvider relationshipNameProvider = Substitute.For <IRelationshipNameProvider>();
relationshipNameProvider.TabName.Returns(TestRelationshipName);
Item anotherGECO = ItemHelper.CreateItem(string.Empty, string.Empty);
anotherGECO.setNewID();
anotherGECO.setProperty("classification", "invalid classification");
IGECOProvider gecoProvider = Substitute.For <IGECOProvider>();
gecoProvider.GetRelatedGECOs(Arg.Any <Item>()).Returns(new[] { anotherGECO });
gecoProvider.GECOIsActive(Arg.Any <Item>()).Returns(true);
gecoProvider.FindAffectedItems(Arg.Any <Item>(), Arg.Any <string>()).Returns(new[] { affectedItem });
string[] availableClassifications = { "available classification" };
var testClass = new TestClass(nameof(TestClass), gecoProvider, relationshipNameProvider, availableClassifications, states);
IReadOnlyCollection <ValidatorInfoModel> validatorInfo
= new[]
{
new ValidatorInfoModel
{
AllowedStates = states,
Name = testClass.Name,
Type = TestType,
},
};
StepHelper.ApplyFinalStep(testClass, validatorInfo);
//act
IList <string> result = testClass.Handle(validationContext).ToList();
//assert
Assert.AreEqual(expectedErrorCounts, result.Count);
}
public Unit CreateUnit(EntityDefault entityDefault, EntityIDGenerator idGenerator)
{
return((Unit)_itemHelper.CreateItem(entityDefault, idGenerator));
}
