require "#{File.dirname(__FILE__)}/../spec_helper"


describe 'Scenario, Integration' do

  let(:clazz) { CukeModeler::Scenario }


  describe 'common behavior' do

    it_should_behave_like 'a model, integration'

  end

  describe 'unique behavior' do

    it 'can be instantiated with the minimum viable Gherkin' do
      source = "#{@scenario_keyword}:"

      expect { clazz.new(source) }.to_not raise_error
    end

    it 'provides a descriptive filename when being parsed from stand alone text' do
      source = "bad scenario text \n #{@scenario_keyword}:\n And a step\n @foo "

      expect { clazz.new(source) }.to raise_error(/'cuke_modeler_stand_alone_scenario\.feature'/)
    end

    it 'stores the original data generated by the parsing adapter', :gherkin4 => true do
      scenario = clazz.new("@tag\n#{@scenario_keyword}: test scenario\ndescription\n#{@step_keyword} a step")
      data = scenario.parsing_data

      expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :description])
      expect(data[:type]).to eq(:Scenario)
    end

    it 'stores the original data generated by the parsing adapter', :gherkin3 => true do
      scenario = clazz.new("@tag\n#{@scenario_keyword}: test scenario\ndescription\n#{@step_keyword} a step")
      data = scenario.parsing_data

      expect(data.keys).to match_array([:type, :tags, :location, :keyword, :name, :steps, :description])
      expect(data[:type]).to eq(:Scenario)
    end

    it 'stores the original data generated by the parsing adapter', :gherkin2 => true do
      scenario = clazz.new("@tag\n#{@scenario_keyword}: test scenario\ndescription\n#{@step_keyword} a step")
      data = scenario.parsing_data

      expect(data.keys).to match_array(['keyword', 'name', 'line', 'description', 'id', 'type', 'steps', 'tags'])
      expect(data['keyword']).to eq('Scenario')
    end

    it 'properly sets its child models' do
      source = "@a_tag
                #{@scenario_keyword}: Test scenario
                  #{@step_keyword} a step"

      scenario = clazz.new(source)
      step = scenario.steps.first
      tag = scenario.tags.first

      expect(step.parent_model).to equal(scenario)
      expect(tag.parent_model).to equal(scenario)
    end

    it 'trims whitespace from its source description' do
      source = ["#{@scenario_keyword}:",
                '  ',
                '        description line 1',
                '',
                '   description line 2',
                '     description line 3               ',
                '',
                '',
                '',
                "  #{@step_keyword} a step"]
      source = source.join("\n")

      scenario = clazz.new(source)
      description = scenario.description.split("\n", -1)

      expect(description).to eq(['     description line 1',
                                 '',
                                 'description line 2',
                                 '  description line 3'])
    end


    describe 'getting ancestors' do

      before(:each) do
        source = "#{@feature_keyword}: Test feature

                    #{@scenario_keyword}: Test test
                      #{@step_keyword} a step"

        file_path = "#{@default_file_directory}/scenario_test_file.feature"
        File.open(file_path, 'w') { |file| file.write(source) }
      end

      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
      let(:scenario) { directory.feature_files.first.feature.tests.first }


      it 'can get its directory' do
        ancestor = scenario.get_ancestor(:directory)

        expect(ancestor).to equal(directory)
      end

      it 'can get its feature file' do
        ancestor = scenario.get_ancestor(:feature_file)

        expect(ancestor).to equal(directory.feature_files.first)
      end

      it 'can get its feature' do
        ancestor = scenario.get_ancestor(:feature)

        expect(ancestor).to equal(directory.feature_files.first.feature)
      end

      it 'returns nil if it does not have the requested type of ancestor' do
        ancestor = scenario.get_ancestor(:test)

        expect(ancestor).to be_nil
      end

    end


    describe 'model population' do

      context 'from source text' do

        let(:source_text) { "#{@scenario_keyword}:" }
        let(:scenario) { clazz.new(source_text) }


        it "models the scenario's keyword" do
          expect(scenario.keyword).to eq("#{@scenario_keyword}")
        end

        it "models the scenario's source line" do
          source_text = "#{@feature_keyword}:

                           #{@scenario_keyword}: foo
                             #{@step_keyword} step"
          scenario = CukeModeler::Feature.new(source_text).tests.first

          expect(scenario.source_line).to eq(3)
        end


        context 'a filled scenario' do

          let(:source_text) { "@tag1 @tag2 @tag3
                                 #{@scenario_keyword}: Scenario name

                                     Scenario description.

                                   Some more.
                                       Even more.

                                 #{@step_keyword} a step
                                 #{@step_keyword} another step" }
          let(:scenario) { clazz.new(source_text) }


          it "models the scenario's name" do
            expect(scenario.name).to eq('Scenario name')
          end

          it "models the scenario's description" do
            description = scenario.description.split("\n", -1)

            expect(description).to eq(['  Scenario description.',
                                       '',
                                       'Some more.',
                                       '    Even more.'])
          end

          it "models the scenario's steps" do
            step_names = scenario.steps.collect { |step| step.text }

            expect(step_names).to eq(['a step', 'another step'])
          end

          it "models the scenario's tags" do
            tag_names = scenario.tags.collect { |tag| tag.name }

            expect(tag_names).to eq(['@tag1', '@tag2', '@tag3'])
          end

        end

        context 'an empty scenario' do

          let(:source_text) { "#{@scenario_keyword}:" }
          let(:scenario) { clazz.new(source_text) }


          it "models the scenario's name" do
            expect(scenario.name).to eq('')
          end

          it "models the scenario's description" do
            expect(scenario.description).to eq('')
          end

          it "models the scenario's steps" do
            expect(scenario.steps).to eq([])
          end

          it "models the scenario's tags" do
            expect(scenario.tags).to eq([])
          end

        end

      end

    end


    describe 'comparison' do

      it 'is equal to a background with the same steps' do
        source = "#{@scenario_keyword}:
                      #{@step_keyword} step 1
                      #{@step_keyword} step 2"
        scenario = clazz.new(source)

        source = "#{@background_keyword}:
                      #{@step_keyword} step 1
                      #{@step_keyword} step 2"
        background_1 = CukeModeler::Background.new(source)

        source = "#{@background_keyword}:
                      #{@step_keyword} step 2
                      #{@step_keyword} step 1"
        background_2 = CukeModeler::Background.new(source)


        expect(scenario).to eq(background_1)
        expect(scenario).to_not eq(background_2)
      end

      it 'is equal to a scenario with the same steps' do
        source = "#{@scenario_keyword}:
                      #{@step_keyword} step 1
                      #{@step_keyword} step 2"
        scenario_1 = clazz.new(source)

        source = "#{@scenario_keyword}:
                      #{@step_keyword} step 1
                      #{@step_keyword} step 2"
        scenario_2 = clazz.new(source)

        source = "#{@scenario_keyword}:
                      #{@step_keyword} step 2
                      #{@step_keyword} step 1"
        scenario_3 = clazz.new(source)


        expect(scenario_1).to eq(scenario_2)
        expect(scenario_1).to_not eq(scenario_3)
      end

      it 'is equal to an outline with the same steps' do
        source = "#{@scenario_keyword}:
                      #{@step_keyword} step 1
                      #{@step_keyword} step 2"
        scenario = clazz.new(source)

        source = "#{@outline_keyword}:
                      #{@step_keyword} step 1
                      #{@step_keyword} step 2
                    #{@example_keyword}:
                      | param |
                      | value |"
        outline_1 = CukeModeler::Outline.new(source)

        source = "#{@outline_keyword}:
                      #{@step_keyword} step 2
                      #{@step_keyword} step 1
                    #{@example_keyword}:
                      | param |
                      | value |"
        outline_2 = CukeModeler::Outline.new(source)


        expect(scenario).to eq(outline_1)
        expect(scenario).to_not eq(outline_2)
      end

    end


    describe 'scenario output' do

      it 'can be remade from its own output' do
        source = "@tag1 @tag2 @tag3
                  #{@scenario_keyword}: A scenario with everything it could have

                  Including a description
                  and then some.

                    #{@step_keyword} a step
                      | value |
                    #{@step_keyword} another step
                      \"\"\"
                      some string
                      \"\"\""
        scenario = clazz.new(source)

        scenario_output = scenario.to_s
        remade_scenario_output = clazz.new(scenario_output).to_s

        expect(remade_scenario_output).to eq(scenario_output)
      end


      context 'from source text' do

        it 'can output an empty scenario' do
          source = ["#{@scenario_keyword}:"]
          source = source.join("\n")
          scenario = clazz.new(source)

          scenario_output = scenario.to_s.split("\n", -1)

          expect(scenario_output).to eq(["#{@scenario_keyword}:"])
        end

        it 'can output a scenario that has a name' do
          source = ["#{@scenario_keyword}: test scenario"]
          source = source.join("\n")
          scenario = clazz.new(source)

          scenario_output = scenario.to_s.split("\n", -1)

          expect(scenario_output).to eq(["#{@scenario_keyword}: test scenario"])
        end

        it 'can output a scenario that has a description' do
          source = ["#{@scenario_keyword}:",
                    'Some description.',
                    'Some more description.']
          source = source.join("\n")
          scenario = clazz.new(source)

          scenario_output = scenario.to_s.split("\n", -1)

          expect(scenario_output).to eq(["#{@scenario_keyword}:",
                                         '',
                                         'Some description.',
                                         'Some more description.'])
        end

        it 'can output a scenario that has steps' do
          source = ["#{@scenario_keyword}:",
                    "#{@step_keyword} a step",
                    '|value|',
                    "#{@step_keyword} another step",
                    '"""',
                    'some string',
                    '"""']
          source = source.join("\n")
          scenario = clazz.new(source)

          scenario_output = scenario.to_s.split("\n", -1)

          expect(scenario_output).to eq(["#{@scenario_keyword}:",
                                         "  #{@step_keyword} a step",
                                         '    | value |',
                                         "  #{@step_keyword} another step",
                                         '    """',
                                         '    some string',
                                         '    """'])
        end

        it 'can output a scenario that has tags' do
          source = ['@tag1 @tag2',
                    '@tag3',
                    "#{@scenario_keyword}:"]
          source = source.join("\n")
          scenario = clazz.new(source)

          scenario_output = scenario.to_s.split("\n", -1)

          expect(scenario_output).to eq(['@tag1 @tag2 @tag3',
                                         "#{@scenario_keyword}:"])
        end

        it 'can output a scenario that has everything' do
          source = ['@tag1 @tag2 @tag3',
                    "#{@scenario_keyword}: A scenario with everything it could have",
                    'Including a description',
                    'and then some.',
                    "#{@step_keyword} a step",
                    '|value|',
                    "#{@step_keyword} another step",
                    '"""',
                    'some string',
                    '"""']
          source = source.join("\n")
          scenario = clazz.new(source)

          scenario_output = scenario.to_s.split("\n", -1)

          expect(scenario_output).to eq(['@tag1 @tag2 @tag3',
                                         "#{@scenario_keyword}: A scenario with everything it could have",
                                         '',
                                         'Including a description',
                                         'and then some.',
                                         '',
                                         "  #{@step_keyword} a step",
                                         '    | value |',
                                         "  #{@step_keyword} another step",
                                         '    """',
                                         '    some string',
                                         '    """'])
        end

      end


      context 'from abstract instantiation' do

        let(:scenario) { clazz.new }


        it 'can output a scenario that has only tags' do
          scenario.tags = [CukeModeler::Tag.new]

          expect { scenario.to_s }.to_not raise_error
        end

        it 'can output a scenario that has only steps' do
          scenario.steps = [CukeModeler::Step.new]

          expect { scenario.to_s }.to_not raise_error
        end

      end

    end

  end

end