public override FixtureModel Compile(CellHandling conversions)
{
var model = new FixtureModel(Key);
model.AddError(_error);
return model;
}
public override GrammarModel ApplyOverrides(GrammarModel grammar)
{
var model = new FixtureModel(key);
model.implementation = implementation;
var over = grammar as FixtureModel;
if (over == null)
{
model.title = title;
model.grammars = grammars.Select(x => x.ApplyOverrides(null)).ToArray();
return(model);
}
model.title = over.title.IsNotEmpty() ? over.title : title;
model.grammars = grammars.Select(g =>
{
var match = over.grammars.FirstOrDefault(x => x.key == g.key);
return(g.ApplyOverrides(match));
}).ToArray();
var keys = model.grammars.Select(x => x.key).ToList();
var missing = over.grammars.Where(x => !keys.Contains(x.key));
missing.Each(x =>
{
model.AddGrammar(x.ApplyOverrides(null));
});
return(model);
}
public void ValidateStepsWithinSection(Section section, FixtureModel fixture)
{
if (fixture.IsMissing)
{
AddError($"Fixture '{fixture.key}' is not implemented");
}
var i = 0;
foreach (var step in section.Children.OfType<Step>())
{
i++;
_locations.Push($"Step #{i}: {step.Key}");
var grammar = fixture.FindGrammar(step.Key);
if (grammar == null)
{
AddError($"Unknown Grammar '{step.Key}'");
}
else
{
if (grammar.IsMissing)
{
AddError($"Grammar '{step.Key}' is not implemented");
}
grammar.PostProcessAndValidate(this, step);
}
_locations.Pop();
}
}
public void ValidateStepsWithinSection(Section section, FixtureModel fixture)
{
if (fixture.IsMissing)
{
AddError($"Fixture '{fixture.key}' is not implemented");
}
var i = 0;
foreach (var step in section.Children.OfType <Step>())
{
i++;
_locations.Push($"Step #{i}: {step.Key}");
var grammar = fixture.FindGrammar(step.Key);
if (grammar == null)
{
AddError($"Unknown Grammar '{step.Key}'");
}
else
{
if (grammar.IsMissing)
{
AddError($"Grammar '{step.Key}' is not implemented");
}
grammar.PostProcessAndValidate(this, step);
}
_locations.Pop();
}
}
public override GrammarModel ApplyOverrides(GrammarModel grammar)
{
if (!(grammar is FixtureModel))
{
return(this);
}
var model = new FixtureModel(key)
{
implementation = implementation
};
var over = grammar.As <FixtureModel>();
model.title = over.title.IsNotEmpty() ? over.title : title;
foreach (var existing in _grammars)
{
var overridden = over.FindGrammar(existing.key);
var combined = overridden == null ? existing : existing.ApplyOverrides(overridden);
combined.errors =
(existing.errors ?? new GrammarError[0]).Concat((overridden?.errors ?? new GrammarError[0]))
.ToArray();
model.AddGrammar(combined);
}
foreach (var specified in over.grammars.Where(x => !grammars.Any(_ => _.key == x.key)))
{
specified.IsMissing = true;
model.AddGrammar(specified);
}
return(model);
}
public void copies_grammars()
{
const string fixtureKey = "a key";
var lib = new FixtureLibrary();
var original = new FixtureModel(fixtureKey);
lib.Models[fixtureKey] = original;
original.AddGrammar(new Sentence { key = "sentence", format = "a format"});
var overrides = new FixtureLibrary();
var overriden = new FixtureModel(fixtureKey);
overrides.Models[fixtureKey] = overriden;
var result = lib.ApplyOverrides(overrides);
result.Models.Count.ShouldBe(1);
var fixture = result.Models[fixtureKey];
ReferenceEquals(fixture, overrides.Models[fixtureKey]).ShouldBeFalse();
fixture.key.ShouldBe(fixtureKey);
fixture.grammars.Length.ShouldBe(1);
var sentence = fixture.grammars[0] as Sentence;
sentence.key.ShouldBe("sentence");
sentence.format.ShouldBe("a format");
}
public override FixtureModel Compile(CellHandling cellHandling)
{
var model = new FixtureModel(Key);
model.AddError(_error);
return(model);
}
public void to_missing_code_with_the_fixture_itself_being_missing()
{
var fixture = new FixtureModel("Something") { IsMissing = true };
fixture.missingCode.ShouldNotBe(FixtureModel.FullyImplementedMessage);
fixture.missingCode.ShouldContain("public class SomethingFixture");
}
public override void ResolveDependencies(FixtureLibrary library)
{
var embeddedKey = fixture.key;
if (library.Models.Has(embeddedKey))
{
fixture = library.Models[embeddedKey];
}
}
public override void ResolveDependencies(FixtureLibrary library)
{
var embeddedKey = fixture.key;
if (library.Models.Has(embeddedKey))
{
fixture = library.Models[embeddedKey];
}
}
void IStepValidator.Start(Section section, FixtureModel fixture)
{
if (fixture == null)
{
_locations.Push($"Collection '{section.Key}'");
}
else
{
_locations.Push($"Collection '{section.Key}' using Fixture '{fixture.key}'");
}
}
public void does_not_overwrite_an_existing_fixture()
{
var file = theFixtureDirectory.AppendPath("One.md");
var original = new FixtureModel("One") {title = "a fancier title"};
FixtureWriter.Write(original, file);
theController.CreateFixture("One");
FixtureReader.ReadFromFile(file)
.title.ShouldBe(original.title);
theClient.ReceivedCalls().Any().ShouldBeFalse();
}
public void can_mark_the_missing_grammars()
{
var system = new FixtureModel("something");
system.AddGrammar(new Sentence {key = "Go1", format = "Go One"});
var overrides = new FixtureModel("something");
overrides.AddGrammar(new Sentence { key = "Go2", format = "Go Two" });
var combined = system.ApplyOverrides(overrides).As<FixtureModel>();
combined.FindGrammar("Go1").IsMissing.ShouldBeFalse();
combined.FindGrammar("Go2").IsMissing.ShouldBeTrue();
}
public void ApplyFixtureOverrides(FixtureLibrary systemLibrary, FixtureLibrary overrides)
{
var embeddedKey = fixture.key;
if (systemLibrary.Models.Has(embeddedKey))
{
var systemFixture = systemLibrary.Models[embeddedKey];
fixture = overrides.Models.Has(embeddedKey)
? systemFixture.ApplyOverrides(overrides.Models[embeddedKey]).As<FixtureModel>()
: systemFixture;
}
else
{
fixture = overrides.Models[embeddedKey];
}
}
public void ApplyFixtureOverrides(FixtureLibrary systemLibrary, FixtureLibrary overrides)
{
var embeddedKey = fixture.key;
if (systemLibrary.Models.Has(embeddedKey))
{
var systemFixture = systemLibrary.Models[embeddedKey];
fixture = overrides.Models.Has(embeddedKey)
? systemFixture.ApplyOverrides(overrides.Models[embeddedKey]).As <FixtureModel>()
: systemFixture;
}
else
{
fixture = overrides.Models[embeddedKey];
}
}
public SystemRecycled CloneWithOverriddenFixtures(FixtureModel[] fixtureArray)
{
var clone = new SystemRecycled
{
error = error,
success = success,
system_full_name = system_full_name,
time = time,
name = name,
system_name = system_name,
properties = properties,
fixtures = fixtureArray
};
return clone;
}
public void overrides_original_title()
{
const string key = "a key";
var lib = new FixtureLibrary();
var original = new FixtureModel(key);
original.title = "A title";
original.implementation = "some implementation";
lib.Models[key] = original;
var overrides = new FixtureLibrary();
var overriden = new FixtureModel(key);
overriden.title = "A new title";
overrides.Models[key] = overriden;
var result = lib.ApplyOverrides(overrides);
result.Models.Count.ShouldBe(1);
var fixture = result.Models[key];
ReferenceEquals(fixture, overrides.Models[key]).ShouldBeFalse();
fixture.title.ShouldBe(overriden.title);
fixture.implementation.ShouldBe(original.implementation);
}
void IStepValidator.Start(Section section, FixtureModel fixture)
{
if (fixture == null)
{
_locations.Push($"Collection '{section.Key}'");
}
else
{
_locations.Push($"Collection '{section.Key}' using Fixture '{fixture.key}'");
}
}
public void to_missing_code_if_nothing_is_missing()
{
var fixture = new FixtureModel("Something") {IsMissing = false};
fixture.missingCode.ShouldBe(FixtureModel.FullyImplementedMessage);
}
public override GrammarModel ApplyOverrides(GrammarModel grammar)
{
if (!(grammar is FixtureModel)) return this;
var model = new FixtureModel(key) {implementation = implementation};
var over = grammar.As<FixtureModel>();
model.title = over.title.IsNotEmpty() ? over.title : title;
foreach (var existing in _grammars)
{
var overridden = over.FindGrammar(existing.key);
var combined = overridden == null ? existing : existing.ApplyOverrides(overridden);
combined.errors =
(existing.errors ?? new GrammarError[0]).Concat((overridden?.errors ?? new GrammarError[0]))
.ToArray();
model.AddGrammar(combined);
}
foreach (var specified in over.grammars.Where(x => !grammars.Any(_ => _.key == x.key)))
{
specified.IsMissing = true;
model.AddGrammar(specified);
}
return model;
}
