vagrant-packet 0.1.2 → 0.1.3

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/pushes/ftp/push_test.rb

@@ -1,300 +0,0 @@
-require_relative "../../../base"
-require "fake_ftp"
-
-require Vagrant.source_root.join("plugins/pushes/ftp/push")
-
-describe VagrantPlugins::FTPPush::Push do
-  include_context "unit"
-
-  let(:env) { isolated_environment }
-  let(:config) do
-    double("config",
-      host:        "127.0.0.1:#{@port}",
-      username:    "sethvargo",
-      password:    "bacon",
-      passive:     false,
-      secure:      false,
-      destination: "/var/www/site",
-    )
-  end
-  let(:ui) do
-    double("ui",
-      info: nil,
-    )
-  end
-
-  subject { described_class.new(env, config) }
-
-  before do
-    allow(env).to receive(:root_path)
-      .and_return(File.expand_path("..", __FILE__))
-    allow(env).to receive(:ui)
-      .and_return(ui)
-  end
-
-  describe "#push" do
-    before(:all) do
-      @server = nil
-      with_random_port do |port1, port2|
-        @port = port1
-        @server = FakeFtp::Server.new(port1, port2)
-      end
-      @server.start
-
-      @dir = Dir.mktmpdir("vagrant-ftp-push")
-      FileUtils.touch("#{@dir}/.hidden.rb")
-      FileUtils.touch("#{@dir}/application.rb")
-      FileUtils.touch("#{@dir}/config.rb")
-      FileUtils.touch("#{@dir}/Gemfile")
-      FileUtils.touch("#{@dir}/data.txt")
-      FileUtils.mkdir("#{@dir}/empty_folder")
-    end
-
-    after(:all) do
-      FileUtils.rm_rf(@dir)
-      @server.stop
-    end
-
-    let(:server) { @server }
-
-    before do
-      allow(config).to receive(:dir)
-        .and_return(@dir)
-
-      allow(config).to receive(:includes)
-        .and_return([])
-
-      allow(config).to receive(:excludes)
-        .and_return(%w(*.rb))
-    end
-
-
-    it "pushes the files to the server" do
-      subject.push
-      expect(server.files).to eq(%w(Gemfile data.txt))
-    end
-  end
-
-  describe "#connect" do
-    before do
-      allow_any_instance_of(VagrantPlugins::FTPPush::FTPAdapter)
-        .to receive(:connect)
-        .and_yield(:ftp)
-      allow_any_instance_of(VagrantPlugins::FTPPush::SFTPAdapter)
-        .to receive(:connect)
-        .and_yield(:sftp)
-    end
-
-    context "when secure is requested" do
-      before do
-        allow(config).to receive(:secure)
-          .and_return(true)
-      end
-
-      it "yields a new SFTPAdapter" do
-        expect { |b| subject.connect(&b) }.to yield_with_args(:sftp)
-      end
-    end
-
-    context "when secure is not requested" do
-      before do
-        allow(config).to receive(:secure)
-          .and_return(false)
-      end
-
-      it "yields a new FTPAdapter" do
-        expect { |b| subject.connect(&b) }.to yield_with_args(:ftp)
-      end
-    end
-  end
-
-  describe "#all_files" do
-    before(:all) do
-      @dir = Dir.mktmpdir("vagrant-ftp-push-push-all-files")
-
-      FileUtils.touch("#{@dir}/.hidden.rb")
-      FileUtils.touch("#{@dir}/application.rb")
-      FileUtils.touch("#{@dir}/config.rb")
-      FileUtils.touch("#{@dir}/Gemfile")
-      FileUtils.mkdir("#{@dir}/empty_folder")
-      FileUtils.mkdir("#{@dir}/folder")
-      FileUtils.mkdir("#{@dir}/folder/.git")
-      FileUtils.touch("#{@dir}/folder/.git/config")
-      FileUtils.touch("#{@dir}/folder/server.rb")
-    end
-
-    after(:all) do
-      FileUtils.rm_rf(@dir)
-    end
-
-    let(:files) do
-      subject.all_files.map do |file|
-        file.sub("#{@dir}/", "")
-      end
-    end
-
-    before do
-      allow(config).to receive(:dir)
-        .and_return(@dir)
-
-      allow(config).to receive(:includes)
-        .and_return(%w(not_a_file.rb still_not_a_file.rb))
-
-      allow(config).to receive(:excludes)
-        .and_return(%w(*.rb))
-    end
-
-    it "returns the list of real files + includes, without excludes" do
-      expect(files).to eq(%w(
-        Gemfile
-        folder/.git/config
-      ))
-    end
-  end
-
-  describe "#includes_files" do
-    before(:all) do
-      @dir = Dir.mktmpdir("vagrant-ftp-push-includes-files")
-
-      FileUtils.touch("#{@dir}/.hidden.rb")
-      FileUtils.touch("#{@dir}/application.rb")
-      FileUtils.touch("#{@dir}/config.rb")
-      FileUtils.touch("#{@dir}/Gemfile")
-      FileUtils.mkdir("#{@dir}/folder")
-      FileUtils.mkdir("#{@dir}/folder/.git")
-      FileUtils.touch("#{@dir}/folder/.git/config")
-      FileUtils.touch("#{@dir}/folder/server.rb")
-    end
-
-    after(:all) do
-      FileUtils.rm_rf(@dir)
-    end
-
-    let(:files) do
-      subject.includes_files.map do |file|
-        file.sub("#{@dir}/", "")
-      end
-    end
-
-    before do
-      allow(config).to receive(:dir)
-        .and_return(@dir)
-    end
-
-    def set_includes(value)
-      allow(config).to receive(:includes)
-        .and_return(value)
-    end
-
-    it "includes the file" do
-      set_includes(["Gemfile"])
-      expect(files).to eq(%w(
-        Gemfile
-      ))
-    end
-
-    it "includes the files that are subdirectories" do
-      set_includes(["folder"])
-      expect(files).to eq(%w(
-        folder
-        folder/.git
-        folder/.git/config
-        folder/server.rb
-      ))
-    end
-
-    it "includes files that match a pattern" do
-      set_includes(["*.rb"])
-      expect(files).to eq(%w(
-        .hidden.rb
-        application.rb
-        config.rb
-      ))
-    end
-  end
-
-  describe "#filter_excludes" do
-    let(:dir) { "/root/dir" }
-
-    let(:list) do
-      %W(
-        #{dir}/.hidden.rb
-        #{dir}/application.rb
-        #{dir}/config.rb
-        #{dir}/Gemfile
-        #{dir}/folder
-        #{dir}/folder/.git
-        #{dir}/folder/.git/config
-        #{dir}/folder/server.rb
-
-        /path/outside/you.rb
-        /path/outside/me.rb
-        /path/outside/folder/bacon.rb
-      )
-    end
-
-    before do
-      allow(config).to receive(:dir)
-        .and_return(dir)
-    end
-
-    it "excludes files" do
-      subject.filter_excludes!(list, %w(*.rb))
-
-      expect(list).to eq(%W(
-        #{dir}/Gemfile
-        #{dir}/folder
-        #{dir}/folder/.git
-        #{dir}/folder/.git/config
-      ))
-    end
-
-    it "excludes files in a directory" do
-      subject.filter_excludes!(list, %w(folder))
-
-      expect(list).to eq(%W(
-        #{dir}/.hidden.rb
-        #{dir}/application.rb
-        #{dir}/config.rb
-        #{dir}/Gemfile
-
-        /path/outside/you.rb
-        /path/outside/me.rb
-        /path/outside/folder/bacon.rb
-      ))
-    end
-
-    it "excludes specific files in a directory" do
-      subject.filter_excludes!(list, %w(/path/outside/folder/*.rb))
-
-      expect(list).to eq(%W(
-        #{dir}/.hidden.rb
-        #{dir}/application.rb
-        #{dir}/config.rb
-        #{dir}/Gemfile
-        #{dir}/folder
-        #{dir}/folder/.git
-        #{dir}/folder/.git/config
-        #{dir}/folder/server.rb
-
-        /path/outside/you.rb
-        /path/outside/me.rb
-      ))
-    end
-
-    it "excludes files outside the #dir" do
-      subject.filter_excludes!(list, %w(/path/outside))
-
-      expect(list).to eq(%W(
-        #{dir}/.hidden.rb
-        #{dir}/application.rb
-        #{dir}/config.rb
-        #{dir}/Gemfile
-        #{dir}/folder
-        #{dir}/folder/.git
-        #{dir}/folder/.git/config
-        #{dir}/folder/server.rb
-      ))
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/pushes/heroku/config_test.rb

@@ -1,99 +0,0 @@
-require_relative "../../../base"
-
-require Vagrant.source_root.join("plugins/pushes/heroku/config")
-
-describe VagrantPlugins::HerokuPush::Config do
-  include_context "unit"
-
-  before(:all) do
-    I18n.load_path << Vagrant.source_root.join("plugins/pushes/heroku/locales/en.yml")
-    I18n.reload!
-  end
-
-  subject { described_class.new }
-
-  let(:machine) { double("machine") }
-
-  describe "#app" do
-    it "defaults to nil" do
-      subject.finalize!
-      expect(subject.app).to be(nil)
-    end
-  end
-
-  describe "#dir" do
-    it "defaults to ." do
-      subject.finalize!
-      expect(subject.dir).to eq(".")
-    end
-  end
-
-  describe "#git_bin" do
-    it "defaults to git" do
-      subject.finalize!
-      expect(subject.git_bin).to eq("git")
-    end
-  end
-
-  describe "#remote" do
-    it "defaults to git" do
-      subject.finalize!
-      expect(subject.remote).to eq("heroku")
-    end
-  end
-
-  describe "#validate" do
-    before do
-      allow(machine).to receive(:env)
-        .and_return(double("env",
-          root_path: "",
-        ))
-
-      subject.app = "bacon"
-      subject.dir = "."
-      subject.git_bin = "git"
-      subject.remote = "heroku"
-    end
-
-    let(:result) { subject.validate(machine) }
-    let(:errors) { result["Heroku push"] }
-
-    context "when the app is missing" do
-      it "does not return an error" do
-        subject.app = ""
-        subject.finalize!
-        expect(errors).to be_empty
-      end
-    end
-
-    context "when the git_bin is missing" do
-      it "returns an error" do
-        subject.git_bin = ""
-        subject.finalize!
-        expect(errors).to include(I18n.t("heroku_push.errors.missing_attribute",
-          attribute: "git_bin",
-        ))
-      end
-    end
-
-    context "when the remote is missing" do
-      it "returns an error" do
-        subject.remote = ""
-        subject.finalize!
-        expect(errors).to include(I18n.t("heroku_push.errors.missing_attribute",
-          attribute: "remote",
-        ))
-      end
-    end
-
-    context "when the dir is missing" do
-      it "returns an error" do
-        subject.dir = ""
-        subject.finalize!
-        expect(errors).to include(I18n.t("heroku_push.errors.missing_attribute",
-          attribute: "dir",
-        ))
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-04f7215b5e3f/test/unit/plugins/pushes/heroku/push_test.rb

@@ -1,313 +0,0 @@
-require_relative "../../../base"
-
-require "vagrant/util/platform"
-
-require Vagrant.source_root.join("plugins/pushes/heroku/push")
-
-describe VagrantPlugins::HerokuPush::Push do
-  include_context "unit"
-
-  before(:all) do
-    I18n.load_path << Vagrant.source_root.join("plugins/pushes/heroku/locales/en.yml")
-    I18n.reload!
-  end
-
-  let(:env) { isolated_environment }
-  let(:config) do
-    double("config",
-      app:     "bacon",
-      dir:     "lib",
-      git_bin: "git",
-      remote:  "heroku",
-    )
-  end
-
-  subject { described_class.new(env, config) }
-
-  describe "#push" do
-    let(:branch) { "master" }
-    let(:dir) { "#{root_path}/#{config.dir}" }
-
-    let(:root_path) do
-      next "/handy/dandy" if !Vagrant::Util::Platform.windows?
-      "C:/handy/dandy" 
-    end
-
-    before do
-      allow(subject).to receive(:git_branch)
-        .and_return(branch)
-      allow(subject).to receive(:verify_git_bin!)
-      allow(subject).to receive(:verify_git_repo!)
-      allow(subject).to receive(:has_git_remote?)
-      allow(subject).to receive(:add_heroku_git_remote)
-      allow(subject).to receive(:git_push_heroku)
-      allow(subject).to receive(:execute!)
-
-      allow(env).to receive(:root_path)
-        .and_return(root_path)
-    end
-
-    it "verifies the git bin is present" do
-      expect(subject).to receive(:verify_git_bin!)
-        .with(config.git_bin)
-      subject.push
-    end
-
-    it "verifies the directory is a git repo" do
-      expect(subject).to receive(:verify_git_repo!)
-        .with(dir)
-      subject.push
-    end
-
-    context "when the heroku remote exists" do
-      before do
-        allow(subject).to receive(:has_git_remote?)
-          .and_return(true)
-      end
-
-      it "does not add the heroku remote" do
-        expect(subject).to_not receive(:add_heroku_git_remote)
-        subject.push
-      end
-    end
-
-    context "when the heroku remote does not exist" do
-      before do
-        allow(subject).to receive(:has_git_remote?)
-          .and_return(false)
-      end
-
-      it "adds the heroku remote" do
-        expect(subject).to receive(:add_heroku_git_remote)
-          .with(config.remote, config.app, dir)
-        subject.push
-      end
-    end
-
-    it "pushes to heroku" do
-      expect(subject).to receive(:git_push_heroku)
-        .with(config.remote, branch, dir)
-      subject.push
-    end
-  end
-
-  describe "#verify_git_bin!" do
-    context "when git does not exist" do
-      before do
-        allow(Vagrant::Util::Which).to receive(:which)
-          .with("git")
-          .and_return(nil)
-      end
-
-      it "raises an exception" do
-        expect {
-          subject.verify_git_bin!("git")
-        } .to raise_error(VagrantPlugins::HerokuPush::Errors::GitNotFound) { |error|
-          expect(error.message).to eq(I18n.t("heroku_push.errors.git_not_found",
-            bin: "git",
-          ))
-        }
-      end
-    end
-
-    context "when git exists" do
-      before do
-        allow(Vagrant::Util::Which).to receive(:which)
-          .with("git")
-          .and_return("git")
-      end
-
-      it "does not raise an exception" do
-        expect { subject.verify_git_bin!("git") }.to_not raise_error
-      end
-    end
-  end
-
-  describe "#verify_git_repo!" do
-    context "when the path is a git repo" do
-      before do
-        allow(File).to receive(:directory?)
-          .with("/repo/path/.git")
-          .and_return(false)
-      end
-
-      it "raises an exception" do
-        expect {
-          subject.verify_git_repo!("/repo/path")
-        } .to raise_error(VagrantPlugins::HerokuPush::Errors::NotAGitRepo) { |error|
-          expect(error.message).to eq(I18n.t("heroku_push.errors.not_a_git_repo",
-            path: "/repo/path",
-          ))
-        }
-      end
-    end
-
-    context "when the path is not a git repo" do
-      before do
-        allow(File).to receive(:directory?)
-          .with("/repo/path/.git")
-          .and_return(true)
-      end
-
-      it "does not raise an exception" do
-        expect { subject.verify_git_repo!("/repo/path") }.to_not raise_error
-      end
-    end
-  end
-
-  describe "#git_push_heroku" do
-    let(:dir) { "." }
-
-    before { allow(subject).to receive(:execute!) }
-
-    it "executes the proper command" do
-      expect(subject).to receive(:execute!)
-        .with("git",
-          "--git-dir", "#{dir}/.git",
-          "--work-tree", dir,
-          "push", "bacon", "hamlet:master",
-        )
-      subject.git_push_heroku("bacon", "hamlet", dir)
-    end
-  end
-
-  describe "#has_git_remote?" do
-    let(:dir) { "." }
-
-    let(:process) do
-      double("process",
-        stdout: "origin\r\nbacon\nhello"
-      )
-    end
-
-    before do
-      allow(subject).to receive(:execute!)
-        .and_return(process)
-    end
-
-    it "executes the proper command" do
-      expect(subject).to receive(:execute!)
-        .with("git",
-          "--git-dir", "#{dir}/.git",
-          "--work-tree", dir,
-          "remote",
-        )
-      subject.has_git_remote?("bacon", dir)
-    end
-
-    it "returns true when the remote exists" do
-      expect(subject.has_git_remote?("origin", dir)).to be(true)
-      expect(subject.has_git_remote?("bacon", dir)).to be(true)
-      expect(subject.has_git_remote?("hello", dir)).to be(true)
-    end
-
-    it "returns false when the remote does not exist" do
-      expect(subject.has_git_remote?("nope", dir)).to be(false)
-    end
-  end
-
-  describe "#add_heroku_git_remote" do
-    let(:dir) { "." }
-
-    before do
-      allow(subject).to receive(:execute!)
-      allow(subject).to receive(:heroku_git_url)
-        .with("app")
-        .and_return("HEROKU_URL")
-    end
-
-    it "executes the proper command" do
-      expect(subject).to receive(:execute!)
-        .with("git",
-          "--git-dir", "#{dir}/.git",
-          "--work-tree", dir,
-          "remote", "add", "bacon", "HEROKU_URL",
-        )
-      subject.add_heroku_git_remote("bacon", "app", dir)
-    end
-  end
-
-  describe "#interpret_app" do
-    it "returns the basename of the directory" do
-      expect(subject.interpret_app("/foo/bar/blitz")).to eq("blitz")
-    end
-  end
-
-  describe "#heroku_git_url" do
-    it "returns the proper string" do
-      expect(subject.heroku_git_url("bacon"))
-        .to eq("git@heroku.com:bacon.git")
-    end
-  end
-
-  describe "#git_dir" do
-    it "returns the .git directory for the path" do
-      expect(subject.git_dir("/path")).to eq("/path/.git")
-    end
-  end
-
-  describe "#git_branch" do
-    let(:stdout) { "" }
-    let(:process) { double("process", stdout: stdout) }
-
-    before do
-      allow(subject).to receive(:execute!)
-        .and_return(process)
-    end
-
-    let(:branch) { subject.git_branch("/path") }
-
-    context "when the branch is not prefixed" do
-      let(:stdout) { "bacon" }
-
-      it "returns the correct name" do
-        expect(branch).to eq("bacon")
-      end
-    end
-  end
-
-  describe "#execute!" do
-    let(:exit_code) { 0 }
-    let(:stdout) { "This is the output" }
-    let(:stderr) { "This is the errput" }
-
-    let(:process) do
-      double("process",
-        exit_code: exit_code,
-        stdout:    stdout,
-        stderr:    stderr,
-      )
-    end
-
-    before do
-      allow(Vagrant::Util::Subprocess).to receive(:execute)
-        .and_return(process)
-    end
-
-    it "creates a subprocess" do
-      expect(Vagrant::Util::Subprocess).to receive(:execute)
-      expect { subject.execute! }.to_not raise_error
-    end
-
-    it "returns the resulting process" do
-      expect(subject.execute!).to be(process)
-    end
-
-    context "when the exit code is non-zero" do
-      let(:exit_code) { 1 }
-
-      it "raises an exception" do
-        klass = VagrantPlugins::HerokuPush::Errors::CommandFailed
-        cmd = ["foo", "bar"]
-
-        expect { subject.execute!(*cmd) }.to raise_error(klass) { |error|
-          expect(error.message).to eq(I18n.t("heroku_push.errors.command_failed",
-            cmd:    cmd.join(" "),
-            stdout: stdout,
-            stderr: stderr,
-          ))
-        }
-      end
-    end
-  end
-end