cuke_modeler 0.4.1 → 1.0.0

data/spec/unit/{bare_bones_unit_specs.rb → shared/bare_bones_models_unit_specs.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-shared_examples_for 'a bare bones element' do
+shared_examples_for 'a bare bones model' do
 
   # clazz must be defined by the calling file
 
-  let(:element) { clazz.new }
+  let(:model) { clazz.new }
 
 
   it 'can be initialized empty' do

data/spec/unit/shared/containing_models_unit_specs.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+shared_examples_for 'a containing model' do
+
+  # clazz must be defined by the calling file
+
+  let(:model) { clazz.new }
+
+
+  it 'has children' do
+    expect(model).to respond_to(:children)
+  end
+
+  it 'returns a collection of children' do
+    expect(model.children).to be_an(Array)
+  end
+
+end

data/spec/unit/shared/described_models_unit_specs.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+shared_examples_for 'a described model' do
+
+  # clazz must be defined by the calling file
+
+  let(:model) { clazz.new }
+
+
+  it 'has a description' do
+    expect(model).to respond_to(:description)
+  end
+
+  it 'can change its description' do
+    expect(model).to respond_to(:description=)
+
+    model.description = :some_description
+    expect(model.description).to eq(:some_description)
+    model.description = :some_other_description
+    expect(model.description).to eq(:some_other_description)
+  end
+
+
+  describe 'abstract instantiation' do
+
+    context 'a new described object' do
+
+      let(:model) { clazz.new }
+
+      it 'starts with no description' do
+        expect(model.description).to be_nil
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/shared/models_unit_specs.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+shared_examples_for 'a model' do
+
+  describe 'common behavior' do
+
+    it_should_behave_like 'a bare bones model'
+    it_should_behave_like 'a prepopulated model'
+    it_should_behave_like 'a nested model'
+    it_should_behave_like 'a containing model'
+    it_should_behave_like 'a stringifiable model'
+
+  end
+
+end

data/spec/unit/shared/named_models_unit_specs.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+shared_examples_for 'a named model' do
+
+  # clazz must be defined by the calling file
+
+  let(:model) { clazz.new }
+
+
+  it 'has a name' do
+    expect(model).to respond_to(:name)
+  end
+
+  it 'can change its name' do
+    expect(model).to respond_to(:name=)
+
+    model.name = :some_name
+    expect(model.name).to eq(:some_name)
+    model.name = :some_other_name
+    expect(model.name).to eq(:some_other_name)
+  end
+
+
+  describe 'abstract instantiation' do
+
+    context 'a new named object' do
+
+      let(:model) { clazz.new }
+
+
+      it 'starts with no name' do
+        expect(model.name).to be_nil
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/shared/nested_models_unit_specs.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+shared_examples_for 'a nested model' do
+
+  # clazz must be defined by the calling file
+
+  let(:nested_model) { clazz.new }
+
+
+  it 'has a parent model' do
+    expect(nested_model).to respond_to(:parent_model)
+  end
+
+  it 'can change its parent model' do
+    expect(nested_model).to respond_to(:parent_model=)
+
+    nested_model.parent_model = :some_parent_model
+    expect(nested_model.parent_model).to eq(:some_parent_model)
+    nested_model.parent_model = :some_other_parent_model
+    expect(nested_model.parent_model).to eq(:some_other_parent_model)
+  end
+
+
+  describe 'abstract instantiation' do
+
+    context 'a new nested object' do
+
+      let(:nested_model) { clazz.new }
+
+
+      it 'starts with no parent model' do
+        expect(nested_model.parent_model).to be_nil
+      end
+
+    end
+
+  end
+
+  it 'has access to its ancestors' do
+    expect(nested_model).to respond_to(:get_ancestor)
+  end
+
+  it 'gets an ancestor based on type' do
+    expect(clazz.instance_method(:get_ancestor).arity).to eq(1)
+  end
+
+  it 'raises and exception if an unknown ancestor type is requested' do
+    expect { nested_model.get_ancestor(:bad_ancestor_type) }.to raise_exception(ArgumentError)
+  end
+
+end

data/spec/unit/shared/parsed_models_unit_specs.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+shared_examples_for 'a parsed model' do
+
+  # clazz must be defined by the calling file
+
+  let(:model) { clazz.new }
+
+
+  it 'can access its original parsing data' do
+    expect(model).to respond_to(:parsing_data)
+  end
+
+  it 'can change its parsing data' do
+    expect(model).to respond_to(:parsing_data=)
+
+    model.parsing_data = :some_parsing_data
+    expect(model.parsing_data).to eq(:some_parsing_data)
+    model.parsing_data = :some_other_parsing_data
+    expect(model.parsing_data).to eq(:some_other_parsing_data)
+  end
+
+
+  describe 'abstract instantiation' do
+
+    context 'a new parsed object' do
+
+      let(:model) { clazz.new }
+
+
+      it 'starts with no parsing data' do
+        expect(model.parsing_data).to be_nil
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/shared/prepopulated_models_unit_specs.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+shared_examples_for 'a prepopulated model' do
+
+  # clazz must be defined by the calling file
+
+  let(:model) { clazz.new }
+
+
+  it 'can take text from which to populate itself' do
+    expect(clazz.instance_method(:initialize).arity).to_not eq(0)
+  end
+
+  it 'will complain if given non-text input' do
+    expect { clazz.new(:not_a_string) }.to raise_error(ArgumentError, 'Can only create models from Strings but was given a Symbol.')
+  end
+
+end

data/spec/unit/shared/sourced_models_unit_specs.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+shared_examples_for 'a sourced model' do
+
+  # clazz must be defined by the calling file
+
+  let(:model) { clazz.new }
+
+
+  it 'has a source line' do
+    expect(model).to respond_to(:source_line)
+  end
+
+  it 'can change its source line' do
+    expect(model).to respond_to(:source_line=)
+
+    model.source_line = :some_source_line
+    expect(model.source_line).to eq(:some_source_line)
+    model.source_line = :some_other_source_line
+    expect(model.source_line).to eq(:some_other_source_line)
+  end
+
+
+  describe 'abstract instantiation' do
+
+    context 'a new sourced object' do
+
+      let(:model) { clazz.new }
+
+
+      it 'starts with no source line' do
+        expect(model.source_line).to be_nil
+      end
+
+    end
+
+  end
+
+end

data/spec/unit/shared/stepped_models_unit_specs.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+shared_examples_for 'a stepped model' do
+
+  # clazz must be defined by the calling file
+
+  let(:model) { clazz.new }
+
+
+  it 'has steps' do
+    expect(model).to respond_to(:steps)
+  end
+
+  it 'can change its steps' do
+    expect(model).to respond_to(:steps=)
+
+    model.steps = :some_steps
+    expect(model.steps).to eq(:some_steps)
+    model.steps = :some_other_steps
+    expect(model.steps).to eq(:some_other_steps)
+  end
+
+
+  describe 'abstract instantiation' do
+
+    context 'a new stepped object' do
+
+      let(:model) { clazz.new }
+
+
+      it 'starts with no steps' do
+        expect(model.steps).to eq([])
+      end
+
+    end
+
+  end
+
+  it 'contains steps' do
+    steps = [:step_1, :step_2, :step_3]
+    model.steps = steps
+
+    steps.each { |step| expect(model.children).to include(step) }
+  end
+
+end

data/spec/unit/shared/stringifiable_models_unit_specs.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+shared_examples_for 'a stringifiable model' do
+
+  # clazz must be defined by the calling file
+
+  let(:model) { clazz.new }
+
+
+  it 'can provide a custom string representation of itself' do
+    expect(model.method(:to_s).owner).to equal(clazz), "#{clazz} does not override #to_s"
+  end
+
+  it 'represents itself with as a string' do
+    expect(model.to_s).to be_a(String)
+  end
+
+end

data/spec/unit/shared/tagged_models_unit_specs.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+shared_examples_for 'a tagged model' do
+
+  # clazz must be defined by the calling file
+
+  let(:model) { clazz.new }
+
+
+  it 'has tags' do
+    expect(model).to respond_to(:tags)
+  end
+
+  it 'can change its tags' do
+    expect(model).to respond_to(:tags=)
+
+    model.tags = :some_tags
+    expect(model.tags).to eq(:some_tags)
+    model.tags = :some_other_tags
+    expect(model.tags).to eq(:some_other_tags)
+  end
+
+
+  describe 'abstract instantiation' do
+
+    context 'a new tagged object' do
+
+      let(:model) { clazz.new }
+
+
+      it 'starts with no tags' do
+        expect(model.tags).to eq([])
+      end
+
+      it 'starts with no inherited tags' do
+        expect(model.applied_tags).to eq([])
+      end
+
+      it 'starts with no tags at all' do
+        expect(model.all_tags).to eq([])
+      end
+
+    end
+
+  end
+
+  it 'has applied tags' do
+    expect(model).to respond_to(:applied_tags)
+  end
+
+  it 'inherits its applied tags from its ancestors' do
+    all_parent_tags = [:parent_tag_1, :parent_tag_2, :grandparent_tag_1]
+    parent = double(:all_tags => all_parent_tags)
+
+    model.parent_model = parent
+
+    expect(model.applied_tags).to match_array(all_parent_tags)
+  end
+
+  it 'knows all of its applicable tags' do
+    all_parent_tags = [:parent_tag_1, :parent_tag_2, :grandparent_tag_1]
+    own_tags = [:tag_1, :tag_2]
+
+    parent = double(:all_tags => all_parent_tags)
+
+    model.parent_model = parent
+    model.tags = own_tags
+
+    expect(model.all_tags).to match_array(all_parent_tags + own_tags)
+  end
+
+end

data/spec/unit/sourceable_unit_spec.rb

@@ -1,17 +1,25 @@
 require 'spec_helper'
 
-SimpleCov.command_name('Sourceable') unless RUBY_VERSION.to_s < '1.9.0'
 
-describe 'Sourceable, Unit' do
+describe 'Sourceable, Unit', :unit_test => true do
 
   let(:nodule) { CukeModeler::Sourceable }
-  let(:element) { Object.new.extend(nodule) }
+  let(:model) { Object.new.extend(nodule) }
 
 
   describe 'unique behavior' do
 
     it 'has a source line' do
-      element.should respond_to(:source_line)
+      expect(model).to respond_to(:source_line)
+    end
+
+    it 'can change its source line' do
+      expect(model).to respond_to(:source_line=)
+
+      model.source_line = :some_source_line
+      expect(model.source_line).to eq(:some_source_line)
+      model.source_line = :some_other_source_line
+      expect(model.source_line).to eq(:some_other_source_line)
     end
 
   end