px_github_changelog_generator 0.0.0

data/spec/unit/generator/generator_processor_spec.rb

@@ -0,0 +1,203 @@
+# frozen_string_literal: true
+
+module GitHubChangelogGenerator
+  describe Generator do
+    let(:default_options) { GitHubChangelogGenerator::Parser.default_options.merge(verbose: false) }
+    let(:options) { {} }
+    let(:generator) { described_class.new(default_options.merge(options)) }
+    let(:bad_label) { { "name" => "BAD" } }
+    let(:good_label) { { "name" => "GOOD" } }
+
+    describe "pull requests" do
+      let(:bad_pull_request) { { "pull_request" => {}, "labels" => [bad_label] } }
+      let(:good_pull_request) { { "pull_request" => {}, "labels" => [good_label] } }
+      let(:unlabeled_pull_request) { { "pull_request" => {}, "labels" => [] } }
+      let(:pull_requests) { [bad_pull_request, good_pull_request, unlabeled_pull_request] }
+
+      describe "#filter_wo_labels" do
+        subject do
+          generator.filter_wo_labels(pull_requests)
+        end
+
+        let(:expected_pull_requests) { pull_requests }
+
+        it { is_expected.to eq(expected_pull_requests) }
+
+        context "when 'add_pr_wo_labels' is false" do
+          let(:options) { { add_pr_wo_labels: false } }
+          let(:expected_pull_requests) { [bad_pull_request, good_pull_request] }
+
+          it { is_expected.to eq(expected_pull_requests) }
+        end
+
+        context "when 'add_pr_wo_labels' is true" do
+          let(:options) { { add_pr_wo_labels: true } }
+
+          it { is_expected.to eq(expected_pull_requests) }
+        end
+      end
+    end
+
+    describe "issues" do
+      let(:bad_issue) { { "labels" => [bad_label] } }
+      let(:good_issue) { { "labels" => [good_label] } }
+      let(:unlabeled_issue) { { "labels" => [] } }
+      let(:issues) { [bad_issue, good_issue, unlabeled_issue] }
+
+      describe "#filter_wo_labels" do
+        subject do
+          generator.filter_wo_labels(issues)
+        end
+
+        let(:expected_issues) { issues }
+
+        it { is_expected.to eq(expected_issues) }
+
+        context "when 'add_issues_wo_labels' is false" do
+          let(:options) { { add_issues_wo_labels: false } }
+          let(:expected_issues) { [bad_issue, good_issue] }
+
+          it { is_expected.to eq(expected_issues) }
+        end
+
+        context "when 'add_issues_wo_labels' is true" do
+          let(:options) { { add_issues_wo_labels: true } }
+
+          it { is_expected.to eq(expected_issues) }
+        end
+      end
+
+      describe "#exclude_issues_by_labels" do
+        subject do
+          generator.exclude_issues_by_labels(issues)
+        end
+
+        let(:expected_issues) { issues }
+
+        it { is_expected.to eq(expected_issues) }
+
+        context "when 'exclude_labels' is provided" do
+          let(:options) { { exclude_labels: %w[BAD BOO] } }
+          let(:expected_issues) { [good_issue, unlabeled_issue] }
+
+          it { is_expected.to eq(expected_issues) }
+        end
+
+        context "with no option given" do
+          subject(:generator) { described_class.new }
+          it "passes everything through when no option given" do
+            result = generator.exclude_issues_by_labels(issues)
+
+            expect(result).to eq(issues)
+          end
+        end
+      end
+
+      describe "#get_filtered_issues" do
+        subject do
+          generator.get_filtered_issues(issues)
+        end
+
+        let(:expected_issues) { issues }
+
+        it { is_expected.to eq(expected_issues) }
+
+        context "when 'exclude_labels' is provided" do
+          let(:options) { { exclude_labels: %w[BAD BOO] } }
+          let(:expected_issues) { [good_issue, unlabeled_issue] }
+
+          it { is_expected.to eq(expected_issues) }
+        end
+
+        context "when 'add_issues_wo_labels' is false" do
+          let(:options) { { add_issues_wo_labels: false } }
+          let(:expected_issues) { [bad_issue, good_issue] }
+
+          it { is_expected.to eq(expected_issues) }
+
+          context "with 'exclude_labels'" do
+            let(:options) { { add_issues_wo_labels: false, exclude_labels: %w[GOOD] } }
+            let(:expected_issues) { [bad_issue] }
+
+            it { is_expected.to eq(expected_issues) }
+          end
+
+          context "with 'include_labels'" do
+            let(:options) { { add_issues_wo_labels: false, include_labels: %w[GOOD] } }
+            let(:expected_issues) { [good_issue] }
+
+            it { is_expected.to eq(expected_issues) }
+          end
+        end
+
+        context "when 'include_labels' is specified" do
+          let(:options) { { include_labels: %w[GOOD] } }
+          let(:expected_issues) { [good_issue, unlabeled_issue] }
+
+          it { is_expected.to eq(expected_issues) }
+        end
+      end
+
+      describe "#find_issues_to_add" do
+        let(:issues) { [issue] }
+        let(:tag_name) { nil }
+        let(:filtered_tags) { [] }
+        before { generator.instance_variable_set(:@filtered_tags, filtered_tags) }
+
+        subject { generator.find_issues_to_add(issues, tag_name) }
+
+        context "issue without milestone" do
+          let(:issue) { { "labels" => [] } }
+
+          it { is_expected.to be_empty }
+        end
+
+        context "milestone title not in the filtered tags" do
+          let(:issue) { { "milestone" => { "title" => "a title" } } }
+          let(:filtered_tags) { [{ "name" => "another name" }] }
+
+          it { is_expected.to be_empty }
+        end
+
+        context "milestone title matches the tag name" do
+          let(:tag_name) { "tag name" }
+          let(:issue) { { "milestone" => { "title" => tag_name } } }
+          let(:filtered_tags) { [{ "name" => tag_name }] }
+
+          it { is_expected.to contain_exactly(issue) }
+        end
+      end
+
+      describe "#remove_issues_in_milestones" do
+        let(:issues) { [issue] }
+
+        context "issue without milestone" do
+          let(:issue) { { "labels" => [] } }
+
+          it "is not filtered" do
+            expect { generator.remove_issues_in_milestones(issues) }.to_not(change { issues })
+          end
+        end
+
+        context "remove issues of open milestones if option is set" do
+          let(:issue) { { "milestone" => { "state" => "open" } } }
+          let(:options) { { issues_of_open_milestones: false } }
+
+          it "is filtered" do
+            expect { generator.remove_issues_in_milestones(issues) }.to change { issues }.to([])
+          end
+        end
+
+        context "milestone in the tag list" do
+          let(:milestone_name) { "milestone name" }
+          let(:issue) { { "milestone" => { "title" => milestone_name } } }
+
+          it "is filtered" do
+            generator.instance_variable_set(:@filtered_tags, [{ "name" => milestone_name }])
+            expect { generator.remove_issues_in_milestones(issues) }.to change { issues }.to([])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/unit/generator/generator_spec.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "github_changelog_generator/generator/generator"
+
+RSpec.describe GitHubChangelogGenerator::Generator do
+  let(:header) { "# Changelog" }
+  let(:generator) { described_class.new({ header: header }) }
+  let(:content) do
+    <<~'BASE'
+      ## [1.3.10](https://github.com/xxx/yyy/tree/1.3.10) (2015-03-18)
+
+      [Full Changelog](https://github.com/xxx/yyy/compare/1.3.9...1.3.10)
+
+      **Fixed bugs:**
+
+
+    BASE
+  end
+  let(:footer) do
+    <<~CREDIT
+      \\* *This Changelog was automatically generated \
+      by [github_changelog_generator]\
+      (https://github.com/github-changelog-generator/github-changelog-generator)*
+    CREDIT
+  end
+
+  context "when the given base file has previously appended template messages" do
+    describe "#remove_old_fixed_string" do
+      it "removes old template headers and footers" do
+        log = +"#{header}\n\n#{header}\n#{header}#{content}\n\n#{footer}\n#{footer}#{footer}"
+
+        expect(generator.send(:remove_old_fixed_string, log)).to eq content
+      end
+    end
+  end
+
+  context "when plain contents string was given" do
+    describe "#insert_fixed_string" do
+      it "append template messages at header and footer" do
+        log = String.new(content)
+        ans = "#{header}\n\n#{content}\n\n#{footer}"
+
+        expect(generator.send(:insert_fixed_string, log)).to eq ans
+      end
+    end
+  end
+end

data/spec/unit/generator/generator_tags_spec.rb

@@ -0,0 +1,337 @@
+# frozen_string_literal: true
+
+describe GitHubChangelogGenerator::Generator do
+  def tag_with_name(tag)
+    {
+      "name" => tag
+    }
+  end
+
+  def tags_from_strings(tags_strings)
+    tags_strings.map do |tag|
+      tag_with_name(tag)
+    end
+  end
+
+  describe "#detect_link_tag_time" do
+    let(:newer_tag) { nil }
+
+    let(:default_options) { GitHubChangelogGenerator::Parser.default_options.merge(verbose: false) }
+    let(:options) do
+      {
+        future_release: "2.0.0"
+      }
+    end
+    let(:generator) { described_class.new(default_options.merge(options)) }
+
+    subject do
+      generator.detect_link_tag_time(newer_tag)
+    end
+
+    context "When the local date is not the same as the UTC date" do
+      before do
+        # 2020-12-27T17:00:00-10:00 is 2020-12-28T03:00:00Z.
+        # GitHub API date & time use UTC, so this instant when converted as a
+        # date should be 2020-12-28.
+        expect(Time).to receive(:new).and_return(Time.new(2020, 12, 27, 17, 0, 0, "-10:00"))
+      end
+
+      it { is_expected.to eq(["2.0.0", "2.0.0", Time.gm(2020, 12, 28, 3)]) }
+    end
+  end
+
+  describe "#tag_section_mapping" do
+    let(:all_tags) { tags_from_strings(%w[8 7 6 5 4 3 2 1]) }
+    let(:sorted_tags) { all_tags }
+
+    let(:default_options) { GitHubChangelogGenerator::Parser.default_options.merge(verbose: false) }
+    let(:options) { {} }
+    let(:generator) { described_class.new(default_options.merge(options)) }
+
+    before do
+      allow_any_instance_of(GitHubChangelogGenerator::OctoFetcher).to receive(:fetch_all_tags).and_return(all_tags)
+      allow(generator).to receive(:fetch_tags_dates).with(all_tags)
+      allow(generator).to receive(:sort_tags_by_date).with(all_tags).and_return(sorted_tags)
+      generator.fetch_and_filter_tags
+    end
+
+    subject do
+      generator.tag_section_mapping
+    end
+
+    shared_examples_for "a section mapping" do
+      it { is_expected.to be_a(Hash) }
+      it { is_expected.to eq(expected_mapping) }
+    end
+
+    shared_examples_for "a full changelog" do
+      let(:expected_mapping) do
+        {
+          tag_with_name("8") => [tag_with_name("7"), tag_with_name("8")],
+          tag_with_name("7") => [tag_with_name("6"), tag_with_name("7")],
+          tag_with_name("6") => [tag_with_name("5"), tag_with_name("6")],
+          tag_with_name("5") => [tag_with_name("4"), tag_with_name("5")],
+          tag_with_name("4") => [tag_with_name("3"), tag_with_name("4")],
+          tag_with_name("3") => [tag_with_name("2"), tag_with_name("3")],
+          tag_with_name("2") => [tag_with_name("1"), tag_with_name("2")],
+          tag_with_name("1") => [nil, tag_with_name("1")]
+        }
+      end
+
+      it_behaves_like "a section mapping"
+    end
+
+    shared_examples_for "a changelog with some exclusions" do
+      let(:expected_mapping) do
+        {
+          tag_with_name("8") => [tag_with_name("6"), tag_with_name("8")],
+          tag_with_name("6") => [tag_with_name("4"), tag_with_name("6")],
+          tag_with_name("4") => [tag_with_name("3"), tag_with_name("4")],
+          tag_with_name("3") => [tag_with_name("1"), tag_with_name("3")],
+          tag_with_name("1") => [nil, tag_with_name("1")]
+        }
+      end
+
+      it_behaves_like "a section mapping"
+    end
+
+    context "with no constraints" do
+      it_behaves_like "a full changelog"
+    end
+
+    context "with since only" do
+      let(:options) { { since_tag: "6" } }
+      let(:expected_mapping) do
+        {
+          tag_with_name("8") => [tag_with_name("7"), tag_with_name("8")],
+          tag_with_name("7") => [tag_with_name("6"), tag_with_name("7")]
+        }
+      end
+
+      it_behaves_like "a section mapping"
+    end
+
+    context "with due only" do
+      let(:options) { { due_tag: "4" } }
+      let(:expected_mapping) do
+        {
+          tag_with_name("3") => [tag_with_name("2"), tag_with_name("3")],
+          tag_with_name("2") => [tag_with_name("1"), tag_with_name("2")],
+          tag_with_name("1") => [nil, tag_with_name("1")]
+        }
+      end
+
+      it_behaves_like "a section mapping"
+    end
+
+    context "with since and due" do
+      let(:options) { { since_tag: "2", due_tag: "5" } }
+      let(:expected_mapping) do
+        {
+          tag_with_name("4") => [tag_with_name("3"), tag_with_name("4")],
+          tag_with_name("3") => [tag_with_name("2"), tag_with_name("3")]
+        }
+      end
+
+      it_behaves_like "a section mapping"
+    end
+
+    context "with excluded tags" do
+      context "as a list of strings" do
+        let(:options) { { exclude_tags: %w[2 5 7] } }
+
+        it_behaves_like "a changelog with some exclusions"
+      end
+
+      context "as a regex" do
+        let(:options) { { exclude_tags: /[257]/ } }
+
+        it_behaves_like "a changelog with some exclusions"
+      end
+
+      context "as a regex string" do
+        let(:options) { { exclude_tags_regex: "[257]" } }
+
+        it_behaves_like "a changelog with some exclusions"
+      end
+    end
+  end
+
+  describe "#filter_included_tags_regex" do
+    subject { generator.filter_included_tags(tags_from_strings(%w[1 2 3])) }
+
+    context "with matching regex" do
+      let(:generator) { GitHubChangelogGenerator::Generator.new(include_tags_regex: "[23]") }
+      it { is_expected.to be_a Array }
+      it { is_expected.to match_array(tags_from_strings(%w[2 3])) }
+    end
+
+    context "with non-matching regex" do
+      let(:generator) { GitHubChangelogGenerator::Generator.new(include_tags_regex: "[45]") }
+      it { is_expected.to be_a Array }
+      it { is_expected.to match_array(tags_from_strings(%w[])) }
+    end
+  end
+
+  describe "#filter_excluded_tags" do
+    subject { generator.filter_excluded_tags(tags_from_strings(%w[1 2 3])) }
+
+    context "with matching string" do
+      let(:generator) { GitHubChangelogGenerator::Generator.new(exclude_tags: %w[3]) }
+      it { is_expected.to be_a Array }
+      it { is_expected.to match_array(tags_from_strings(%w[1 2])) }
+    end
+
+    context "with non-matching string" do
+      let(:generator) { GitHubChangelogGenerator::Generator.new(exclude_tags: %w[invalid tags]) }
+      it { is_expected.to be_a Array }
+      it { is_expected.to match_array(tags_from_strings(%w[1 2 3])) }
+    end
+
+    context "with matching regex" do
+      let(:generator) { GitHubChangelogGenerator::Generator.new(exclude_tags: /[23]/) }
+      it { is_expected.to be_a Array }
+      it { is_expected.to match_array(tags_from_strings(%w[1])) }
+    end
+
+    context "with non-matching regex" do
+      let(:generator) { GitHubChangelogGenerator::Generator.new(exclude_tags: /[abc]/) }
+      it { is_expected.to be_a Array }
+      it { is_expected.to match_array(tags_from_strings(%w[1 2 3])) }
+    end
+  end
+
+  describe "#filter_excluded_tags_regex" do
+    subject { generator.filter_excluded_tags(tags_from_strings(%w[1 2 3])) }
+
+    context "with matching regex" do
+      let(:generator) { GitHubChangelogGenerator::Generator.new(exclude_tags_regex: "[23]") }
+      it { is_expected.to be_a Array }
+      it { is_expected.to match_array(tags_from_strings(%w[1])) }
+    end
+
+    context "with non-matching regex" do
+      let(:generator) { GitHubChangelogGenerator::Generator.new(exclude_tags_regex: "[45]") }
+      it { is_expected.to be_a Array }
+      it { is_expected.to match_array(tags_from_strings(%w[1 2 3])) }
+    end
+  end
+
+  describe "#filter_since_tag" do
+    context "with filled array" do
+      subject { generator.filter_since_tag(tags_from_strings(%w[1 2 3])) }
+
+      context "with valid since tag" do
+        let(:generator) { GitHubChangelogGenerator::Generator.new(since_tag: "2") }
+        it { is_expected.to be_a Array }
+        it { is_expected.to match_array(tags_from_strings(%w[1 2])) }
+
+        context "with since tag set to the most recent tag" do
+          let(:generator) { GitHubChangelogGenerator::Generator.new(since_tag: "1") }
+          it { is_expected.to match_array(tags_from_strings(%w[1])) }
+        end
+      end
+
+      context "with invalid since tag" do
+        let(:generator) { GitHubChangelogGenerator::Generator.new(since_tag: "Invalid tag") }
+        it { expect { subject }.to raise_error(GitHubChangelogGenerator::ChangelogGeneratorError) }
+      end
+    end
+
+    context "with empty array" do
+      subject { generator.filter_since_tag(tags_from_strings(%w[])) }
+
+      context "with invalid since tag" do
+        let(:generator) { GitHubChangelogGenerator::Generator.new(since_tag: "Invalid tag") }
+        it { expect { subject }.to raise_error(GitHubChangelogGenerator::ChangelogGeneratorError) }
+      end
+    end
+  end
+
+  describe "#filter_due_tag" do
+    context "with filled array" do
+      subject { generator.filter_due_tag(tags_from_strings(%w[1 2 3])) }
+
+      context "with valid due tag" do
+        let(:generator) { GitHubChangelogGenerator::Generator.new(due_tag: "2") }
+        it { is_expected.to be_a Array }
+        it { is_expected.to match_array(tags_from_strings(%w[3])) }
+      end
+
+      context "with invalid due tag" do
+        let(:generator) { GitHubChangelogGenerator::Generator.new(due_tag: "Invalid tag") }
+        it { expect { subject }.to raise_error(GitHubChangelogGenerator::ChangelogGeneratorError) }
+      end
+    end
+
+    context "with empty array" do
+      subject { generator.filter_due_tag(tags_from_strings(%w[])) }
+
+      context "with invalid due tag" do
+        let(:generator) { GitHubChangelogGenerator::Generator.new(due_tag: "Invalid tag") }
+        it { expect { subject }.to raise_error(GitHubChangelogGenerator::ChangelogGeneratorError) }
+      end
+    end
+  end
+
+  describe "#get_time_of_tag" do
+    current_time = Time.now
+    before(:all) { @generator = GitHubChangelogGenerator::Generator.new }
+    context "run with nil parameter" do
+      it "should raise ChangelogGeneratorError" do
+        expect { @generator.get_time_of_tag nil }.to raise_error(GitHubChangelogGenerator::ChangelogGeneratorError)
+      end
+    end
+    context "fetch already filled tag" do
+      before { @generator.instance_variable_set :@tag_times_hash, "valid_tag" => current_time }
+      subject { @generator.get_time_of_tag tag_with_name("valid_tag") }
+      it { is_expected.to be_a_kind_of(Time) }
+      it { is_expected.to eq(current_time) }
+    end
+    context "fetch not filled tag" do
+      before do
+        mock = double("fake fetcher")
+        allow(mock).to receive_messages(fetch_date_of_tag: current_time)
+        @generator.instance_variable_set :@fetcher, mock
+      end
+      subject do
+        of_tag = @generator.get_time_of_tag(tag_with_name("valid_tag"))
+        of_tag
+      end
+      it { is_expected.to be_a_kind_of(Time) }
+      it { is_expected.to eq(current_time) }
+    end
+  end
+
+  describe "#sort_tags_by_date" do
+    let(:time1) { Time.now }
+    let(:time2) { Time.now }
+    let(:time3) { Time.now }
+
+    before(:all) do
+      @generator = GitHubChangelogGenerator::Generator.new
+    end
+
+    before do
+      @generator.instance_variable_set(:@tag_times_hash, "valid_tag1" => time1,
+                                                         "valid_tag2" => time2,
+                                                         "valid_tag3" => time3)
+    end
+
+    subject do
+      @generator.sort_tags_by_date(tags)
+    end
+    context "sort unsorted tags" do
+      let(:tags) { tags_from_strings %w[valid_tag1 valid_tag2 valid_tag3] }
+
+      it { is_expected.to be_a_kind_of(Array) }
+      it { is_expected.to match_array(tags.reverse!) }
+    end
+    context "sort sorted tags" do
+      let(:tags) { tags_from_strings %w[valid_tag3 valid_tag2 valid_tag1] }
+
+      it { is_expected.to be_a_kind_of(Array) }
+      it { is_expected.to match_array(tags) }
+    end
+  end
+end

data/spec/unit/generator/section_spec.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module GitHubChangelogGenerator
+  RSpec.describe Section do
+    let(:options) { {} }
+    subject(:section) { described_class.new(options) }
+
+    describe "#encapsulate_string" do
+      let(:string) { "" }
+
+      context "with the empty string" do
+        it "returns the string" do
+          expect(section.send(:encapsulate_string, string)).to eq string
+        end
+      end
+
+      context "with a string with an escape-needing character in it" do
+        let(:string) { "<Inside> and outside" }
+
+        it "returns the string escaped" do
+          expect(section.send(:encapsulate_string, string)).to eq '\\<Inside\\> and outside'
+        end
+      end
+
+      context "with a backticked string with an escape-needing character in it" do
+        let(:string) { 'back `\` slash' }
+
+        it "returns the string" do
+          expect(section.send(:encapsulate_string, string)).to eq 'back `\` slash'
+        end
+      end
+    end
+
+    describe "#normalize_body" do
+      context "it should remove CR" do
+        let(:body) { "Some content from GitHub\r\n\r\nUser is describing something" }
+        it "returns a cleaned body" do
+          expect(section.send(:normalize_body, body)).to eq "Some content from GitHub\n\nUser is describing something"
+        end
+      end
+    end
+  end
+end