public void ThereAreOpenIssuesWithThePropertiesWithTable(Table issues)
{
_project = UserWorkflow.LogonAs(Admin)
.CreateNewProject()
.AddIssues(issues.ToIssues())
.CurrentProject;
}
public void setAllowedSkills(Table table)
{
skills=new List<Skill>();
foreach (List<String> rows in table.Data){
skills.Add(new Skill(rows[0]));
}
}
public bool Includes(Table expectedTable)
{
foreach (var exRow in expectedTable.Hashes())
{
bool hasMatchingRow = false;
foreach (var acRow in this.Hashes())
{
foreach (var key in exRow.Keys)
{
if (exRow[key] == acRow[key])
{
hasMatchingRow = true;
}
else
{
hasMatchingRow = false;
break;
}
}
if (hasMatchingRow)
break;
}
if (!hasMatchingRow)
return false;
}
return true;
}
public void UserSeesTheFollowingIssuesInHisReportWithTable(
string user, Table issues) {
IList<Issue> reportedIssues = UserWorkflow.LogonAs(user)
.UsingProject(_project)
.ViewAssignedIssuesReport()
.Issues;
Assert.AreEqual(issues.ToIssues(), reportedIssues);
}
public void AssertSameAsShouldThrow()
{
Table actualTable = new Table();
Table expectedTable = new Table();
Assert.Throws<TableAssertionException>(delegate()
{
actualTable.AssertSameAs(expectedTable);
});
}
public void UserSeesTheFollowingIssuesInHisReportWithTable(
string user, Table issues)
{
IList <Issue> reportedIssues = UserWorkflow.LogonAs(user)
.UsingProject(_project)
.ViewAssignedIssuesReport()
.Issues;
Assert.AreEqual(issues.ToIssues(), reportedIssues);
}
public void ThereAreOpenIssuesWithThePropertiesWithTable()
{
var table = new Table();
table.Data.Add(new List<string> { "Title", "Severity" });
table.Data.Add(new List<string> { "Chuck Norris beat me", "Fatal" });
_underTest.ThereAreOpenIssuesWithThePropertiesWithTable(table);
_underTest.TheIssueWithTitleIsAssignedToUser("Chuck Norris beat me", "Ninja2");
_underTest.UserSeesTheFollowingIssuesInHisReportWithTable("Ninja2", table);
_underTest.UserSeesNoIssuesInHisReport("Ninja1");
}
public void HeadersShouldReturnListOfHeaders()
{
Table tbl = new Table();
tbl.Data.Add(new List<string>(new[] { "Provider", "Date" }));
tbl.Data.Add(new List<string>(new[] { "Nurse (Ann)", "01/15/2010" }));
tbl.Data.Add(new List<string>(new[] { "Doctor (Zeke)", "01/15/2010" }));
Assert.That(tbl.Headers(), Is.EqualTo(new List<string>(new[] { "Provider", "Date" })));
}
public void checkExpectedTechniques(Table table) {
// System.Diagnostics.Debugger.Break();
Table actualTable = new Table();
actualTable.Data.Add(ToList ( "technique", "danger" ));
foreach (Skill skill in skills){
if (skill.AvailableTo(opponent)){
actualTable.Data.Add(
ToList(skill.Name(), skill.Danger(opponent)));
}
}
Console.WriteLine(actualTable.ToString());
table.AssertSameAs(actualTable);
}
public void AssertSameAsShouldProvideTablesInException()
{
Table actualTable = new Table();
Table expectedTable = new Table();
try
{
actualTable.AssertSameAs(expectedTable);
}
catch (TableAssertionException ex)
{
Assert.AreSame(actualTable, ex.Actual);
Assert.AreSame(expectedTable, ex.Expected);
}
}
public void HashesShouldTreatFirstRowAsHeaders()
{
Table table = new Table();
table.Data.Add(new List<string> { "item", "count" });
table.Data.Add(new List<string> { "cucumbers", "3" });
table.Data.Add(new List<string> { "bananas", "5" });
table.Data.Add(new List<string> { "tomatoes", "2" });
var hashes = table.Hashes();
Assert.That(hashes.Count, Is.EqualTo(3));
Assert.That(hashes[0].Keys, Has.Member("item"));
Assert.That(hashes[0].Keys, Has.Member("count"));
Assert.That(hashes[1]["item"], Is.EqualTo("bananas"));
}
public void IncludesShouldReturnFalseWithOneColumnNotMatching()
{
Table expTable = new Table();
Table actTable = new Table();
expTable.Data.Add(new List<string>(new[] { "Provider" }));
expTable.Data.Add(new List<string>(new[] { "Nurse (Sue)" }));
actTable.Data.Add(new List<string>(new[] { "Provider" }));
actTable.Data.Add(new List<string>(new[] { "Nurse (Ann)" }));
actTable.Data.Add(new List<string>(new[] { "Doctor (Zeke)" }));
Assert.That(actTable.Includes(expTable), Is.False);
}
public Table JsonToTable(string jsonTable)
{
Table table = new Table();
if (jsonTable == null || jsonTable == String.Empty)
{
return table;
}
ArgumentException invalidDataEx = new ArgumentException("Input not in expected format. Expecting a JSON array of string arrays.");
JArray rows;
try
{
rows = JArray.Parse(jsonTable);
}
catch (Exception)
{
throw invalidDataEx;
}
if (rows.Count == 0)
{
return table;
}
foreach (JToken row in rows.Children())
{
if (!(row.Type == JTokenType.Array))
{
throw invalidDataEx;
}
var values = new List<string>();
foreach (JToken cell in row.Children())
{
if (!(cell.Type == JTokenType.String))
{
throw invalidDataEx;
}
values.Add(cell.Value<string>() as string);
}
table.Data.Add(values);
}
return table;
}
public void IncludesShouldReturnFalseWithTwoColumnsWithMismatchInFirstColumn()
{
Table expTable = new Table();
Table actTable = new Table();
expTable.Data.Add(new List<string>(new[] { "Provider", "Date" }));
expTable.Data.Add(new List<string>(new[] { "Nurse (Sue)", "01/15/2010" }));
actTable.Data.Add(new List<string>(new[] { "Provider", "Date" }));
actTable.Data.Add(new List<string>(new[] { "Nurse (Ann)", "01/15/2010" }));
actTable.Data.Add(new List<string>(new[] { "Doctor (Zeke)", "01/15/2010" }));
Assert.That(actTable.Includes(expTable), Is.False);
}
private string TableDiffResponse(Table expectedTable, Table actualTable)
{
TypeConverter converter = TypeDescriptor.GetConverter(typeof(Table));
string expectedTableJson = (string)converter.ConvertToString(expectedTable);
string actualTableJson = (string)converter.ConvertToString(actualTable);
return String.Format("[\"diff!\", [{0},{1}]]", expectedTableJson, actualTableJson);
}
public void NinjaWithExperience(Table table)
{
List<Dictionary<string, string>> hashes = table.Hashes();
Dictionary<String, String> ninjaProperties = hashes[0];
ninja = new Ninja(ninjaProperties["belt_level"]);
}
public TableAssertionException(Table actualTable, Table expectedTable)
{
this.Actual = actualTable;
this.Expected = expectedTable;
}
public void ShouldConvertToString()
{
Table table = new Table();
table.Data.Add(new List<string>(new string[] { "foo", "1" }));
table.Data.Add(new List<string>(new string[] { "bar", "2" }));
string expectedJsonString = "[[\"foo\",\"1\"],[\"bar\",\"2\"]]";
string actualJsonString = null;
Assert.DoesNotThrow(delegate {
TypeConverter converter = TypeDescriptor.GetConverter(typeof(Table));
actualJsonString = (string)converter.ConvertToString(table);
});
Assert.That(actualJsonString, Is.EqualTo(expectedJsonString));
}
public void HeadersShouldReturnEmptyListForEmptyTable()
{
Table tbl = new Table();
Assert.That(tbl.Headers(), Is.EqualTo(new List<string>()));
}
public void RowHashesShouldThrowForThreeColumnTable()
{
Table tbl = new Table();
tbl.Data.Add(new List<string>(new[] { "Value1", "Value1", "Value1" }));
tbl.Data.Add(new List<string>(new[] { "Value2", "Value2", "Value2" }));
tbl.Data.Add(new List<string>(new[] { "Value3", "Value3", "Value3" }));
Assert.Throws<InvalidOperationException>(delegate
{
tbl.RowHashes();
});
}
public void TableToJsonString_ShouldConvertFromTable_EmptyTable()
{
Table table = new Table();
string expectedJsonString = "[]";
string actualJsonString = converter.TableToJsonString(table);
Assert.That(actualJsonString, Is.EqualTo(expectedJsonString));
}
public void RowHashesShouldReturnDictionaryForTwoColumnTable()
{
Table tbl = new Table();
tbl.Data.Add(new List<string>(new[] { "Key1", "Value1" }));
tbl.Data.Add(new List<string>(new[] { "Key2", "Value2" }));
tbl.Data.Add(new List<string>(new[] { "Key3", "Value3" }));
Assert.That(tbl.RowHashes(), Is.EqualTo(new Dictionary<string, string>()
{
{ "Key1", "Value1" },
{ "Key2", "Value2" },
{ "Key3", "Value3" }
}
));
}
public void RowHashesShouldThrowForEmptyTable()
{
Table tbl = new Table();
Assert.Throws<InvalidOperationException>(delegate
{
tbl.RowHashes();
});
}
public void TableToJsonString_ShouldConvertFromTable_HeaderAndDataRows()
{
Table table = new Table();
table.Data.Add(new List<string>(new string[] { "item", "count" }));
table.Data.Add(new List<string>(new string[] { "cucumbers", "3" }));
table.Data.Add(new List<string>(new string[] { "bananas", "5" }));
table.Data.Add(new List<string>(new string[] { "tomatoes", "2" }));
string expectedJsonString = "[[\"item\",\"count\"],[\"cucumbers\",\"3\"],[\"bananas\",\"5\"],[\"tomatoes\",\"2\"]]";
string actualJsonString = converter.TableToJsonString(table);
Assert.That(actualJsonString, Is.EqualTo(expectedJsonString));
}
public void IncludesShouldReturnTrueWithTwoColumnMatching()
{
Table expTable = new Table();
Table actTable = new Table();
expTable.Data.Add(new List<string>(new[] { "Provider", "Date" }));
expTable.Data.Add(new List<string>(new[] { "Nurse (Ann)", "01/15/2010" }));
actTable.Data.Add(new List<string>(new[] { "Provider", "Date" }));
actTable.Data.Add(new List<string>(new[] { "Nurse (Ann)", "01/15/2010" }));
actTable.Data.Add(new List<string>(new[] { "Doctor (Zeke)", "01/15/2010" }));
Assert.That(actTable.Includes(expTable));
}
public void TableToJsonString_ShouldConvertFromTable_HeaderRowOnly()
{
Table table = new Table();
table.Data.Add(new List<string>(new string[] { "item", "count" }));
string expectedJsonString = "[[\"item\",\"count\"]]";
string actualJsonString = converter.TableToJsonString(table);
Assert.That(actualJsonString, Is.EqualTo(expectedJsonString));
}
public void AssertSameAs(Table expectedTable)
{
throw new TableAssertionException(this, expectedTable);
}
public string TableToJsonString(Table table)
{
return JsonConvert.SerializeObject(table.Data, Formatting.None);
}
public static void TableDiff()
{
Table table1 = new Table();
table1.Data.Add(new List<string> { "foo", "bar" });
Table table2 = new Table();
table1.Data.Add(new List<string> { "foo", "baz" });
table1.AssertSameAs(table2);
}
public void ThereAreOpenIssuesWithThePropertiesWithTable(Table issues) {
_project = UserWorkflow.LogonAs(Admin)
.CreateNewProject()
.AddIssues(issues.ToIssues())
.CurrentProject;
}
