dpl-connect 1.8.43

data/spec/provider/pypi_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'dpl/provider/pypi'
+
+describe DPL::Provider::PyPI do
+  subject :provider do
+    described_class.new(DummyContext.new, :user => 'foo', :password => 'bar')
+  end
+
+  describe "#config" do
+    it 'accepts a user and a password' do
+      expect(provider.config[:servers]['pypi']).to include 'username: foo'
+      expect(provider.config[:servers]['pypi']).to include 'password: bar'
+    end
+  end
+
+  describe "#initialize" do
+    example "with :distributions option containing 'bdist_wheel'" do
+      expect(described_class).to receive(:pip).with("wheel")
+      described_class.new(DummyContext.new, :user => 'foo', :password => 'bar', :distributions => 'bdist_wheel sdist')
+    end
+  end
+
+  describe "#check_auth" do
+    example do
+      expect(provider).to receive(:log).with("Authenticated as foo")
+      provider.check_auth
+    end
+  end
+
+  describe "#push_app" do
+    example do
+      expect(provider.context).to receive(:shell).with("python setup.py sdist")
+      expect(provider.context).to receive(:shell).with("twine upload -r pypi dist/*")
+      expect(provider.context).to receive(:shell).with("rm -rf dist/*")
+      expect(provider.context).not_to receive(:shell).with("python setup.py upload_docs  -r https://upload.pypi.org/legacy/")
+      provider.push_app
+    end
+
+    example "with :distributions option" do
+      provider.options.update(:distributions => 'sdist bdist')
+      expect(provider.context).to receive(:shell).with("python setup.py sdist bdist")
+      expect(provider.context).to receive(:shell).with("twine upload -r pypi dist/*")
+      expect(provider.context).to receive(:shell).with("rm -rf dist/*")
+      expect(provider.context).not_to receive(:shell).with("python setup.py upload_docs  -r https://upload.pypi.org/legacy/")
+      provider.push_app
+    end
+
+    example "with :server option" do
+      provider.options.update(:server => 'http://blah.com')
+      expect(provider.context).to receive(:shell).with("python setup.py sdist")
+      expect(provider.context).to receive(:shell).with("twine upload -r pypi dist/*")
+      expect(provider.context).to receive(:shell).with("rm -rf dist/*")
+      expect(provider.context).not_to receive(:shell).with("python setup.py upload_docs  -r http://blah.com")
+      provider.push_app
+    end
+
+    example "with :skip_upload_docs option" do
+      provider.options.update(:skip_upload_docs => true)
+      expect(provider.context).to receive(:shell).with("python setup.py sdist")
+      expect(provider.context).to receive(:shell).with("twine upload -r pypi dist/*")
+      expect(provider.context).to receive(:shell).with("rm -rf dist/*")
+      expect(provider.context).not_to receive(:shell).with("python setup.py upload_docs -r https://upload.pypi.org/legacy/")
+      provider.push_app
+    end
+
+    context "with :skip_upload_docs option being false" do
+      before :each do
+        provider.options.update(:skip_upload_docs => false)
+      end
+
+      it "runs upload_docs" do
+        expect(provider.context).to receive(:shell).with("python setup.py sdist")
+        expect(provider.context).to receive(:shell).with("twine upload -r pypi dist/*")
+        expect(provider.context).to receive(:shell).with("rm -rf dist/*")
+        expect(provider.context).to receive(:shell).with("python setup.py upload_docs  -r https://upload.pypi.org/legacy/")
+        provider.push_app
+      end
+
+      example "with :docs_dir option" do
+        provider.options.update(:docs_dir => 'some/dir')
+        expect(provider.context).to receive(:shell).with("python setup.py sdist")
+        expect(provider.context).to receive(:shell).with("twine upload -r pypi dist/*")
+        expect(provider.context).to receive(:shell).with("rm -rf dist/*")
+        expect(provider.context).to receive(:shell).with("python setup.py upload_docs --upload-dir some/dir -r https://upload.pypi.org/legacy/")
+        provider.push_app
+      end
+    end
+
+  end
+
+  describe "#write_servers" do
+    example do
+      f = double(:f)
+      expect(f).to receive(:puts).with("    pypi")
+      expect(f).to receive(:puts).with("[pypi]")
+      expect(f).to receive(:puts).with(["repository: https://upload.pypi.org/legacy/",
+                                    "username: foo",
+                                    "password: bar"
+                                   ])
+      provider.write_servers(f)
+    end
+  end
+end

data/spec/provider/releases_spec.rb

@@ -0,0 +1,303 @@
+require 'spec_helper'
+require 'dpl/provider/releases'
+require 'octokit'
+
+describe DPL::Provider::Releases do
+  subject :provider do
+    described_class.new(DummyContext.new, :api_key => '0123445789qwertyuiop0123445789qwertyuiop', :file => 'blah.txt')
+  end
+
+  describe "#travis_tag" do
+    example "When $TRAVIS_TAG is nil" do
+      provider.context.env['TRAVIS_TAG'] = nil
+
+      expect(provider.travis_tag).to eq(nil)
+    end
+
+    example "When $TRAVIS_TAG if set but empty" do
+      provider.context.env['TRAVIS_TAG'] = nil
+
+      expect(provider.travis_tag).to eq(nil)
+    end
+
+    example "When $TRAVIS_TAG if set" do
+      provider.context.env['TRAVIS_TAG'] = "foo"
+
+      expect(provider.travis_tag).to eq("foo")
+    end
+  end
+
+  describe "#api" do
+    example "With API key" do
+      api = double(:api)
+      expect(::Octokit::Client).to receive(:new).with(:access_token => '0123445789qwertyuiop0123445789qwertyuiop').and_return(api)
+      expect(provider.api).to eq(api)
+    end
+
+    example "With username and password" do
+      api = double(:api)
+      provider.options.update(:user => 'foo')
+      provider.options.update(:password => 'bar')
+
+      expect(::Octokit::Client).to receive(:new).with(:login => 'foo', :password  => 'bar').and_return(api)
+      expect(provider.api).to eq(api)
+    end
+  end
+
+  describe "#releases" do
+    example "With ENV Slug" do
+      allow(provider).to receive(:slug).and_return("foo/bar")
+
+      expect(provider.api).to receive(:releases).with("foo/bar")
+      provider.releases
+    end
+
+    example "With repo option" do
+      provider.options.update(:repo => 'bar/foo')
+
+      expect(provider.api).to receive(:releases).with('bar/foo')
+      provider.releases
+    end
+  end
+
+  describe "#files" do
+    example "without file globbing and a single file" do
+      expect(provider.files).to eq(['blah.txt'])
+    end
+
+    example "without file globbing and multiple files" do
+      provider.options.update(:file => ['foo.txt', 'bar.txt'])
+      expect(provider.files).to eq(['foo.txt', 'bar.txt'])
+    end
+
+    example "with file globbing and a single glob" do
+      provider.options.update(:file_glob => true)
+      provider.options.update(:file => 'bl*.txt')
+      expect(::Dir).to receive(:glob).with('bl*.txt').and_return(['blah.txt'])
+      expect(provider.files).to eq(['blah.txt'])
+    end
+
+    example "with file globbing and multiple globs" do
+      provider.options.update(:file_glob => true)
+      provider.options.update(:file => ['f*.txt', 'b*.txt'])
+      expect(::Dir).to receive(:glob).with('f*.txt').and_return(['foo.txt'])
+      expect(::Dir).to receive(:glob).with('b*.txt').and_return(['bar.txt'])
+      expect(provider.files).to eq(['foo.txt', 'bar.txt'])
+    end
+  end
+
+  describe "#needs_key?" do
+    example do
+      expect(provider.needs_key?).to eq(false)
+    end
+  end
+
+  describe "#check_app" do
+    example "Without $TRAVIS_TAG" do
+      allow(provider).to receive(:travis_tag).and_return(nil)
+      allow(provider).to receive(:slug).and_return("foo/bar")
+      allow(provider).to receive(:get_tag).and_return("foo")
+
+      expect(provider.context).to receive(:shell).with("git fetch --tags")
+      expect(provider).to receive(:log).with("Deploying to repo: foo/bar")
+      expect(provider).to receive(:log).with("Current tag is: foo")
+
+      provider.check_app
+    end
+
+    example "With $TRAVIS_TAG" do
+      allow(provider).to receive(:travis_tag).and_return("bar")
+      allow(provider).to receive(:slug).and_return("foo/bar")
+
+      expect(provider.context).not_to receive(:shell).with("git fetch --tags")
+      expect(provider).to receive(:log).with("Deploying to repo: foo/bar")
+      expect(provider).to receive(:log).with("Current tag is: bar")
+
+      provider.check_app
+    end
+  end
+
+  describe "#get_tag" do
+    example "Without $TRAVIS_TAG" do
+      allow(provider).to receive(:travis_tag).and_return(nil)
+      allow(provider).to receive(:`).and_return("bar")
+
+      expect(provider.get_tag).to eq("bar")
+    end
+
+    example "With $TRAVIS_TAG" do
+      allow(provider).to receive(:travis_tag).and_return("foo")
+
+      expect(provider.get_tag).to eq("foo")
+    end
+  end
+
+  describe "#check_auth" do
+    example "With proper permissions" do
+      allow_message_expectations_on_nil
+      allow(provider).to receive(:user)
+      allow(provider).to receive(:setup_auth)
+      expect(provider.api).to receive(:scopes).and_return(["public_repo"])
+      expect(provider.user).to receive(:name).and_return("foo")
+      expect(provider).to receive(:log).with("Logged in as foo")
+      provider.check_auth
+    end
+
+    example "With improper permissions" do
+      allow_message_expectations_on_nil
+      allow(provider).to receive(:user)
+      allow(provider).to receive(:setup_auth)
+      expect(provider.api).to receive(:scopes).exactly(2).times.and_return([])
+      expect { provider.check_auth }.to raise_error(DPL::Error)
+    end
+  end
+
+  describe "#push_app" do
+    example "When Release Exists but has no Files" do
+      allow_message_expectations_on_nil
+
+      provider.options.update(:file => ["test/foo.bar", "bar.txt"])
+
+      allow(provider).to receive(:releases).and_return([""])
+      allow(provider).to receive(:get_tag).and_return("v0.0.0")
+
+      provider.releases.map do |release|
+        allow(release).to receive(:tag_name).and_return("v0.0.0")
+        allow(release).to receive(:rels).and_return({:self => nil})
+        allow(release.rels[:self]).to receive(:href)
+      end
+
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => [""]})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([])
+
+      expect(provider.api).to receive(:upload_asset).with(anything, "test/foo.bar", {:name=>"foo.bar", :content_type=>"application/octet-stream"})
+      expect(provider.api).to receive(:upload_asset).with(anything, "bar.txt", {:name=>"bar.txt", :content_type=>"text/plain"})
+      expect(provider.api).to receive(:update_release).with(anything, hash_including(:draft => false))
+
+      provider.push_app
+    end
+
+    example "When Release Exists and has Files" do
+      allow_message_expectations_on_nil
+
+      provider.options.update(:file => ["test/foo.bar", "bar.txt"])
+
+      allow(provider).to receive(:releases).and_return([""])
+      allow(provider).to receive(:get_tag).and_return("v0.0.0")
+
+      provider.releases.map do |release|
+        allow(release).to receive(:tag_name).and_return("v0.0.0")
+        allow(release).to receive(:rels).and_return({:self => nil})
+        allow(release.rels[:self]).to receive(:href)
+      end
+
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => [""]})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([double(:name => "foo.bar", :url => 'foo-bar-url'), double(:name => "foo.foo", :url => 'foo-foo-url')])
+
+      expect(provider.api).to receive(:upload_asset).with(anything, "bar.txt", {:name=>"bar.txt", :content_type=>"text/plain"})
+      expect(provider).to receive(:log).with("foo.bar already exists, skipping.")
+      expect(provider.api).to receive(:update_release).with(anything, hash_including(:draft => false))
+
+      provider.push_app
+    end
+
+    example "When Release Exists and has Files but overwrite flag is true" do
+      allow_message_expectations_on_nil
+
+      provider.options.update(:file => ["exists.txt"])
+      provider.options.update(:overwrite => true)
+
+      allow(provider).to receive(:releases).and_return([""])
+      allow(provider).to receive(:get_tag).and_return("v0.0.0")
+
+      provider.releases.map do |release|
+        allow(release).to receive(:tag_name).and_return("v0.0.0")
+        allow(release).to receive(:rels).and_return({:self => nil})
+        allow(release.rels[:self]).to receive(:href)
+      end
+
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => [""]})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([double(:name => "exists.txt", :url => "release-url")])
+
+      expect(provider.api).to receive(:delete_release_asset).with("release-url").and_return(true)
+      expect(provider.api).to receive(:upload_asset).with(anything, "exists.txt", {:name=>"exists.txt", :content_type=>"text/plain"})
+      expect(provider.api).to receive(:update_release).with(anything, hash_including(:draft => false))
+
+      provider.push_app
+    end
+
+    example "When Release Doesn't Exist" do
+      allow_message_expectations_on_nil
+
+      provider.options.update(:file => ["test/foo.bar", "bar.txt"])
+
+      allow(provider).to receive(:releases).and_return([""])
+
+      provider.releases.map do |release|
+        allow(release).to receive(:tag_name).and_return("foo")
+        allow(release).to receive(:rels).and_return({:self => nil})
+        allow(release.rels[:self]).to receive(:href)
+      end
+
+      allow(provider.api).to receive(:create_release)
+      allow(provider.api.create_release).to receive(:rels).and_return({:self => nil})
+      allow(provider.api.create_release.rels[:slef]).to receive(:href)
+
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => nil})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([])
+
+      expect(provider.api).to receive(:upload_asset).with(anything, "test/foo.bar", {:name=>"foo.bar", :content_type=>"application/octet-stream"})
+      expect(provider.api).to receive(:upload_asset).with(anything, "bar.txt", {:name=>"bar.txt", :content_type=>"text/plain"})
+      expect(provider.api).to receive(:update_release).with(anything, hash_including(:draft => false))
+
+      provider.push_app
+    end
+
+    example "With Release Number" do
+      allow_message_expectations_on_nil
+
+      provider.options.update(:file => ["bar.txt"])
+      provider.options.update(:release_number => "1234")
+
+      allow(provider).to receive(:slug).and_return("foo/bar")
+
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => nil})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([])
+
+      expect(provider.api).to receive(:upload_asset).with("https://api.github.com/repos/foo/bar/releases/1234", "bar.txt", {:name=>"bar.txt", :content_type=>"text/plain"})
+      expect(provider.api).to receive(:update_release).with(anything, hash_including(:draft => false))
+
+      provider.push_app
+    end
+
+    example "When draft is true" do
+      allow_message_expectations_on_nil
+
+      provider.options.update(:file => ["bar.txt"])
+      provider.options.update(:release_number => "1234")
+      provider.options.update(:draft => true)
+
+      allow(provider).to receive(:slug).and_return("foo/bar")
+
+      allow(provider.api).to receive(:release)
+      allow(provider.api.release).to receive(:rels).and_return({:assets => nil})
+      allow(provider.api.release.rels[:assets]).to receive(:get).and_return({:data => nil})
+      allow(provider.api.release.rels[:assets].get).to receive(:data).and_return([])
+
+      expect(provider.api).to receive(:upload_asset).with("https://api.github.com/repos/foo/bar/releases/1234", "bar.txt", {:name=>"bar.txt", :content_type=>"text/plain"})
+      expect(provider.api).to receive(:update_release).with(anything, hash_including(:draft => true))
+
+      provider.push_app
+    end
+  end
+end

data/spec/provider/rubygems_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+require 'rubygems'
+require 'gems'
+require 'dpl/provider/rubygems'
+
+describe DPL::Provider::RubyGems do
+  subject :provider do
+    described_class.new(DummyContext.new, :app => 'example', :api_key => 'foo')
+  end
+
+  describe "#api" do
+    example "with an api key" do
+      expect(::Gems).to receive(:key=).with('foo')
+      provider.setup_auth
+    end
+
+    example "with a username and password" do
+      provider.options.update(:user => 'test', :password => 'blah')
+      provider.options.delete(:api_key)
+      expect(::Gems).to receive(:username=).with('test')
+      expect(::Gems).to receive(:password=).with('blah')
+      provider.setup_auth
+    end
+  end
+
+  describe "#check_auth" do
+    example do
+      provider.options.update(:user => 'test', :password => 'blah')
+      provider.options.delete(:api_key)
+      expect(provider).to receive(:log).with("Authenticated with username test")
+      provider.check_auth
+    end
+  end
+
+  describe "#check_app" do
+    example do
+      expect(::Gems).to receive(:info).with('example').and_return({'name' => 'example'})
+      expect(provider).to receive(:log).with("Looking up gem example")
+      expect(provider).to receive(:log).with("Found gem example")
+      provider.check_app
+    end
+  end
+
+  describe "#push_app" do
+    after(:each) do
+      expect(File).to receive(:new).with('File').and_return('Test file')
+      expect(provider).to receive(:log).with('Yes!')
+      provider.push_app
+    end
+
+    example "with options[:app]" do
+      provider.options.update(:app => 'example')
+      expect(provider.context).to receive(:shell).with("gem build example.gemspec")
+      expect(Dir).to receive(:glob).with('example-*.gem').and_yield('File')
+      expect(::Gems).to receive(:push).with('Test file').and_return('Yes!')
+    end
+
+    example "with options[:gem]" do
+      provider.options.update(:gem => 'example-gem')
+      expect(provider.context).to receive(:shell).with("gem build example-gem.gemspec")
+      expect(Dir).to receive(:glob).with('example-gem-*.gem').and_yield('File')
+      expect(::Gems).to receive(:push).with('Test file').and_return('Yes!')
+    end
+
+    example "with options[:gemspec]" do
+      provider.options.update(:gemspec => 'blah.gemspec')
+      expect(provider.context).to receive(:shell).with("gem build blah.gemspec")
+      expect(Dir).to receive(:glob).with('blah-*.gem').and_yield('File')
+      expect(::Gems).to receive(:push).with('Test file').and_return('Yes!')
+    end
+
+    example "with options[:host]" do
+      provider.options.update(:host => 'http://example.com')
+      expect(provider.context).to receive(:shell).with("gem build example.gemspec")
+      expect(Dir).to receive(:glob).with('example-*.gem').and_yield('File')
+      expect(::Gems).to receive(:push).with('Test file', host='http://example.com').and_return('Yes!')
+    end
+  end
+
+  describe "#setup_gem" do
+    example "with options[:gem] and options[:app] set" do
+      provider.options.update(:gem => 'test', :app => 'blah')
+      provider.setup_gem
+      expect(provider.options[:gem]).to eq('test')
+    end
+
+    example "with options[:app] set" do
+      provider.options.update(:app => 'foo')
+      provider.setup_gem
+      expect(provider.options[:gem]).to eq('foo')
+    end
+
+    example "with options[:gem] set" do
+      provider.options.update(:gem => 'bar')
+      provider.setup_gem
+      expect(provider.options[:gem]).to eq('bar')
+    end
+  end
+
+  describe "#gemspec" do
+    example do
+      provider.options.update(:gemspec => 'test.gemspec')
+      expect(provider.gemspec).to eq('test')
+    end
+  end
+end