abak-flow 1.0.3 → 1.0.4

data/spec/abak-flow/branch_spec.rb

@@ -1,55 +0,0 @@
-# coding: utf-8
-require "spec_helper"
-
-describe Abak::Flow::Branch do
-  let(:develop) { double("Branch", full: "develop") }
-  let(:master) { double("Branch", full: "master") }
-  let(:hotfix) { double("Branch", full: "hotfix/PR-2011") }
-  let(:feature) { double("Branch", full: "feature/JP-515") }
-  let(:noname) { double("Branch", full: "my_own/what_i_want/branch_name") }
-
-  describe "#name" do
-    it { described_class.new(feature).name.should eq "feature/JP-515" }
-    it { described_class.new(develop).name.should eq "develop" }
-  end
-
-  describe "#prefix" do
-    it { described_class.new(develop).prefix.should be_nil }
-    it { described_class.new(hotfix).prefix.should eq "hotfix" }
-    it { described_class.new(feature).prefix.should eq "feature" }
-    it { described_class.new(noname).prefix.should eq "my_own/what_i_want" }
-  end
-
-  describe "#task" do
-    it { described_class.new(develop).task.should be_nil }
-    it { described_class.new(feature).task.should eq "JP-515" }
-    it { described_class.new(noname).task.should eq "branch_name" }
-  end
-
-  describe "#hotfix?" do
-    it { described_class.new(develop).hotfix?.should eq false }
-    it { described_class.new(noname).hotfix?.should eq false }
-    it { described_class.new(feature).hotfix?.should eq false }
-    it { described_class.new(hotfix).hotfix?.should eq true }
-  end
-
-  describe "#feature?" do
-    it { described_class.new(master).feature?.should eq false }
-    it { described_class.new(noname).feature?.should eq false }
-    it { described_class.new(hotfix).feature?.should eq false }
-    it { described_class.new(feature).feature?.should eq true }
-  end
-
-  describe "#task?" do
-    it { described_class.new(develop).task?.should eq false }
-    it { described_class.new(noname).task?.should eq false }
-    it { described_class.new(hotfix).task?.should eq true }
-    it { described_class.new(feature).task?.should eq true }
-  end
-
-  describe "#tracker_task" do
-    it { described_class.new(develop).tracker_task.should be_nil }
-    it { described_class.new(feature).tracker_task.should eq "JP-515" }
-    it { described_class.new(noname).tracker_task.should be_nil }
-  end
-end

data/spec/abak-flow/branches_spec.rb

@@ -1,20 +0,0 @@
-# coding: utf-8
-require "spec_helper"
-
-describe Abak::Flow::Branches do
-  describe "Interface" do
-    subject { described_class }
-
-    it { should respond_to :current_branch }
-  end
-
-  describe "#current_branch" do
-    let(:branch) { double("Branch") }
-    let(:git) { double("Git", current_branch: "my_branch", branches: {"my_branch" => branch}) }
-
-    before { described_class.stub(:git).and_return git }
-    subject { described_class.current_branch }
-
-    it { should be_kind_of Abak::Flow::Branch }
-  end
-end

data/spec/abak-flow/configuration_spec.rb

@@ -1,73 +0,0 @@
-# coding: utf-8
-require "spec_helper"
-
-describe Abak::Flow::Configuration do
-  let(:oauth_user) { "Admin" }
-  let(:oauth_token) { "0123456789" }
-  let(:proxy_server) { "http://www.super-proxy.net:4080/" }
-  let(:environment) { "http://www.linux-proxy.net:6666/" }
-  let(:instance) { described_class.clone.instance }
-
-  let(:git) do
-    double("Git Config", config: {
-      "abak-flow.oauth-user" => oauth_user,
-      "abak-flow.oauth-token" => oauth_token,
-      "abak-flow.proxy-server" => proxy_server,
-      "abak-flow.locale" => "ru"
-    })
-  end
-
-  context "when all config elements missing" do
-    let(:git) { double("Git Config", config: {}) }
-
-    before do
-      described_class.any_instance.stub(:environment_http_proxy).and_return nil
-      described_class.any_instance.stub(:git).and_return git
-      described_class.any_instance.stub(:setup_locale)
-    end
-
-    subject { instance.params }
-
-    its(:oauth_user) { should be_nil }
-    its(:oauth_token) { should be_nil }
-    its(:proxy_server) { should be_nil }
-    its(:locale) { should eq "en" }
-  end
-
-  context "when all config elements exists" do
-    before do
-      described_class.any_instance.stub(:environment_http_proxy).and_return nil
-      described_class.any_instance.stub(:git).and_return git
-      described_class.any_instance.stub(:setup_locale)
-    end
-
-    subject { instance.params }
-
-    its(:oauth_user) { should eq "Admin" }
-    its(:oauth_token) { should eq "0123456789" }
-    its(:locale) { should eq "ru" }
-    its(:proxy_server) { should eq "http://www.super-proxy.net:4080/" }
-  end
-
-  context "when various proxy server set" do
-    before do
-      described_class.any_instance.stub(:git).and_return git
-      described_class.any_instance.stub(:setup_locale)
-    end
-
-    subject { instance.params.proxy_server }
-
-    context "when ENV and git config setup proxy server" do
-      before { described_class.any_instance.stub(:environment_http_proxy).and_return environment }
-
-      it { should eq "http://www.super-proxy.net:4080/" }
-    end
-
-    context "when only ENV setup proxy server" do
-      before { described_class.any_instance.stub(:environment_http_proxy).and_return environment }
-      before { git.stub(:config).and_return({}) }
-
-      it { should eq "http://www.linux-proxy.net:6666/" }
-    end
-  end
-end

data/spec/abak-flow/git_spec.rb

@@ -1,12 +0,0 @@
-# coding: utf-8
-require "spec_helper"
-
-describe Abak::Flow::Git do
-  subject { described_class.clone.instance }
-
-  describe "Interface" do
-    it { should respond_to :git }
-    it { should respond_to :command }
-    it { should respond_to :command_lines }
-  end
-end

data/spec/abak-flow/github_client_spec.rb

@@ -1,15 +0,0 @@
-# coding: utf-8
-require "spec_helper"
-
-describe Abak::Flow::GithubClient do
-  let(:instance) { described_class.clone.instance }
-
-  describe "#connection" do
-    let(:options) { {login: "login", password: "password"} }
-
-    before { described_class.any_instance.stub(:connection_options).and_return options }
-    after { instance.connection }
-
-    it { Octokit::Client.should_receive(:new).with({login: "login", password: "password"}) }
-  end
-end

data/spec/abak-flow/messages_spec.rb

@@ -1,146 +0,0 @@
-# coding: utf-8
-require "spec_helper"
-
-describe Abak::Flow::Messages do
-  let(:messages) { Abak::Flow::Messages.new "my_scope" }
-  subject { messages }
-
-  describe "Interface" do
-    it { should respond_to :each }
-    it { should respond_to :push }
-    it { should respond_to :<< }
-    it { should respond_to :to_s }
-    it { should respond_to :header }
-    it { should respond_to :print }
-    it { should respond_to :pretty_print }
-    it { should respond_to :pp }
-    it { should respond_to :empty? }
-    it { should respond_to :translate }
-    it { should respond_to :t }
-  end
-
-  describe "Public methods" do
-    describe "#header" do
-      before { I18n.should_receive(:t).with(:header, scope: "my_scope").and_return "+HEADER+" }
-      subject { messages.header}
-
-      it { should eq "+HEADER+" }
-    end
-
-    describe "#push" do
-      context "when no elements pushed" do
-        its(:elements) { should be_empty }
-      end
-
-      context "when push only one element" do
-        before { messages.push :hello }
-
-        its(:elements) { should eq [:hello] }
-      end
-
-      context "when push more than one element" do
-        before { messages.push :hello }
-        before { messages.push :world }
-
-        its(:elements) { should eq [:hello, :world] }
-      end
-    end
-
-    describe "#each" do
-      context "when no block given" do
-        it { expect { messages.each }.to raise_error ArgumentError }
-      end
-
-      context "when block given" do
-        before do
-          messages.push :hello
-          messages.push :linux
-
-          I18n.should_receive(:t).with(:linux, scope: "my_scope").and_return "linux_t"
-          I18n.should_receive(:t).with(:hello, scope: "my_scope").and_return "hello_t"
-        end
-
-        it { expect { |b| messages.each(&b) }.to yield_successive_args("hello_t", "linux_t") }
-      end
-    end
-
-    describe "#to_s" do
-      subject { messages.to_s }
-
-      context "when messages are empty" do
-        it { should be_empty }
-      end
-
-      context "when messages are not empty" do
-        before do
-          messages.push :hello
-          messages.push :linux
-
-          I18n.should_receive(:t).with(:linux, scope: "my_scope").and_return "linux_t"
-          I18n.should_receive(:t).with(:hello, scope: "my_scope").and_return "hello_t"
-        end
-
-        it { should include "hello_t" }
-        it { should include "linux_t" }
-      end
-    end
-
-    describe "#pretty_print" do
-      subject { messages.pp }
-
-      context "when messages are empty" do
-        it { should be_empty }
-      end
-
-      context "when messages are not empty" do
-        before do
-          messages.push :hello
-          messages.push :linux
-
-          I18n.should_receive(:t).with(:header, scope: "my_scope").and_return "+HEADER+"
-          I18n.should_receive(:t).with(:linux, scope: "my_scope").and_return "linux_t"
-          I18n.should_receive(:t).with(:hello, scope: "my_scope").and_return "hello_t"
-        end
-
-        it { should include "hello_t" }
-        it { should include "linux_t" }
-        it { should include "+HEADER+" }
-      end
-    end
-
-    describe "#translate" do
-      context "when translate from current scope" do
-        before { I18n.should_receive(:t).with(:word, scope: "my_scope").and_return "WORD" }
-        subject { messages.t :word }
-
-        it { should eq "WORD" }
-      end
-
-      context "when translate from different scope" do
-        before { I18n.should_receive(:t).with(:hello, scope: "diff_scope").and_return "HELLO" }
-        subject { messages.t :hello, {scope: "diff_scope"} }
-
-        it { should eq "HELLO" }
-      end
-    end
-
-    describe "#purge!" do
-      context "when message have elements" do
-        before { messages.push :hello }
-        before { messages.push :linux }
-        before { messages.purge! }
-
-        subject { messages }
-
-        it { should be_empty }
-      end
-
-      context "when message have no elements" do
-        before { messages.purge! }
-        subject { messages }
-
-        it { should be_empty }
-      end
-    end
-  end
-end

data/spec/abak-flow/project_spec.rb

@@ -1,52 +0,0 @@
-# coding: utf-8
-require "spec_helper"
-
-describe Abak::Flow::Project do
-  let(:origin) { double("Origin", name: "origin", url: "git@github.com:Strech/abak-flow.git") }
-  let(:upstream) { double("Upstream", name: "upstream", url: "http://github.com/Godlike/abak-flow-new.git") }
-  let(:git) { double("Git", remotes: [origin, upstream]) }
-  let(:instance) { Abak::Flow::Project.clone.instance }
-
-  context "when initialize project with two remote repositories" do
-    before { Abak::Flow::Project.any_instance.stub(:git).and_return git }
-
-    subject { instance.remotes }
-
-    it { should have_key :origin }
-    it { should have_key :upstream }
-  end
-
-  context "when initialize project with some wrong repositories" do
-    let(:wrong) { double("Wrong", name: "wrong", url: "git@wrong-site.com:Me/wrong-flow.git") }
-    let(:git) { double("Git", remotes: [origin, wrong]) }
-
-    before { Abak::Flow::Project.any_instance.stub(:git).and_return git }
-
-    subject { instance.remotes }
-
-    it { should have_key :origin }
-    it { should_not have_key :upstream }
-  end
-
-  describe "#Remote" do
-    before { Abak::Flow::Project.any_instance.stub(:git).and_return git }
-
-    describe "#origin" do
-      subject { instance.remotes[:origin] }
-
-      its(:owner) { should eq "Strech" }
-      its(:project) { should eq "abak-flow" }
-      its(:repo) { should eq origin }
-      its(:to_s) { should eq "Strech/abak-flow" }
-    end
-
-    describe "#upstream" do
-      subject { instance.remotes[:upstream] }
-
-      its(:owner) { should eq "Godlike" }
-      its(:project) { should eq "abak-flow-new" }
-      its(:repo) { should eq upstream }
-      its(:to_s) { should eq "Godlike/abak-flow-new" }
-    end
-  end
-end