dockistrano 0.0.1

data/spec/dockistrano/cli_spec.rb

@@ -0,0 +1,296 @@
+require 'spec_helper'
+
+describe Dockistrano::Cli do
+
+  let(:service) { double(registry: "registry.provider.tld", image_name: "application", tag: "develop", volumes: [], backing_services: { "postgresql" => backing_service }, environment_variables: {}, newer_version_available?: false, stop: nil) }
+  let(:backing_service) { double(full_image_name: "registry.provider.tld/postgresql:develop", image_name: "postgresql", running?: false, newer_version_available?: false, start: nil, stop: nil) }
+  let(:hipache) { double }
+  let(:output) { capture(:stdout) { described_class.start(command) } }
+
+  before do
+    allow(Dockistrano::Service).to receive(:factory).and_return(service)
+  end
+
+  context "doc status" do
+    let(:command) { ["status"] }
+
+    it "prints the DOCKISTRANO_ENVIRONMENT" do
+      expect(output).to include("DOCKISTRANO_ENVIRONMENT: default")
+    end
+
+    it "prints the DOCKER_HOST_IP" do
+      expect(output).to include("DOCKER_HOST_IP: 127.0.0.1")
+    end
+
+    it "prints the DOCKER_BINARY" do
+      expect(output).to include("DOCKER_BINARY:")
+      expect(output).to include("bin/docker")
+    end
+
+    it "prints the registry" do
+      expect(output).to include("registry: #{service.registry}")
+    end
+
+    it "prints the name of the image" do
+      expect(output).to include("image name: #{service.image_name}")
+    end
+
+    it "prints the tag" do
+      expect(output).to include("tag: #{service.tag}")
+    end
+
+    it "lists all dependencies" do
+      expect(output).to include(backing_service.full_image_name)
+    end
+
+    it "lists environment variables" do
+      allow(service).to receive(:environment_variables).and_return({ "VARIABLE" => "value"} )
+      expect(output).to include("VARIABLE=value")
+    end
+
+    it "lists the Hipache configuration" do
+      allow(Dockistrano::Hipache).to receive(:new).with("127.0.0.1").and_return(hipache)
+      allow(hipache).to receive(:status).and_return({ "somehostname.dev" => ["127.0.0.1:1000", "23.45.56.75:1234"] })
+      expect(output).to include("somehostname.dev: 127.0.0.1:1000, 23.45.56.75:1234")
+    end
+  end
+
+  context "doc build" do
+    let(:command) { ["build"] }
+
+    it "builds a container" do
+      expect(service).to receive(:build).and_return(true)
+      expect(service).to receive(:test).and_return(true)
+      expect(service).to receive(:push).and_return(true)
+      expect(output).to include("built")
+      expect(output).to include("tests")
+      expect(output).to include("pushed")
+    end
+
+    it "doesn't run the tests and push when building failed" do
+      expect(service).to receive(:build).and_return(false)
+      expect(service).to_not receive(:test)
+      expect(service).to_not receive(:push)
+      expect { output }.to raise_error(SystemExit)
+    end
+
+    it "doesn't push when tests failed" do
+      expect(service).to receive(:build).and_return(true)
+      expect(service).to receive(:test).and_return(false)
+      expect(service).to_not receive(:push)
+      expect { output }.to raise_error(SystemExit)
+    end
+  end
+
+  context "doc pull" do
+    let(:command) { ["pull"] }
+
+    it "pulls a backing service when newer versions are available" do
+      expect(backing_service).to receive(:newer_version_available?).and_return(true)
+      expect(backing_service).to receive(:pull)
+      expect(output).to include("Pulled")
+    end
+
+    it "doesn't pull a service when no new versions are available" do
+      expect(backing_service).to receive(:newer_version_available?).and_return(false)
+      expect(backing_service).to_not receive(:pull)
+      expect(output).to include("Uptodate")
+    end
+
+    it "pulls the application container when newer versions are available" do
+      expect(service).to receive(:newer_version_available?).and_return(true)
+      expect(service).to receive(:pull)
+      expect(output).to include("Pulled")
+    end
+
+    it "doesn't pull the application container when no newer versions are available" do
+      expect(service).to receive(:newer_version_available?).and_return(false)
+      expect(service).to_not receive(:pull)
+      expect(output).to include("Uptodate")
+    end
+  end
+
+  context "doc push" do
+    it "pushes the current container" do
+      expect(service).to receive(:push)
+      described_class.start(["push"])
+    end
+  end
+
+  context "doc start-services" do
+    let(:command) { ["start-services"] }
+
+    it "starts a backing service when it is not running" do
+      expect(backing_service).to receive(:running?).and_return(false)
+      expect(backing_service).to receive(:start)
+      expect(output).to include("Started")
+    end
+
+    it "does nothing when a backing services is already running" do
+      expect(backing_service).to receive(:running?).and_return(true)
+      expect(backing_service).to_not receive(:start)
+      expect(output).to include("Running")
+    end
+  end
+
+  context "doc stop-all" do
+    let(:command) { ["stop-all"] }
+
+    it "stops the current container" do
+      expect(service).to receive(:stop)
+      expect(output).to include("Stopped")
+    end
+
+    it "stops all backing services" do
+      expect(backing_service).to receive(:running?).and_return(true)
+      expect(backing_service).to receive(:stop)
+      expect(output).to include("Stopped")
+    end
+  end
+
+  context "doc start" do
+    let(:command) { ["start"] }
+
+    it "starts the services when not running" do
+      expect(service).to receive(:running?).and_return(false)
+      expect(service).to receive(:start)
+      expect(output).to include("Started")
+    end
+
+    it "doesn't start the services when already running" do
+      expect(service).to receive(:running?).and_return(true)
+      expect(service).to_not receive(:start)
+      expect(output).to include("Running")
+    end
+
+    it "prints an error when environment variables are missing" do
+      expect(service).to receive(:running?).and_return(false)
+      expect(service).to receive(:start).and_raise(Dockistrano::Service::EnvironmentVariablesMissing.new("error message"))
+      expect(output).to include("error message")
+    end
+  end
+
+  context "doc stop" do
+    let(:command) { ["stop"] }
+
+    it "stops the current container" do
+      expect(service).to receive(:stop)
+      expect(output).to include("Stopped")
+    end
+  end
+
+  context "doc stop ID" do
+    let(:command) { ["stop", "123456789"] }
+
+    it "stops the container with the id" do
+      expect(Dockistrano::Docker).to receive(:stop).with("123456789")
+      expect(output).to include("Stopped")
+    end
+  end
+
+  context "doc restart" do
+    let(:command) { ["restart"] }
+
+    it "restarts the current container" do
+      expect(service).to receive(:stop)
+      expect(service).to receive(:start)
+      expect(output).to include("Stopped")
+      expect(output).to include("Started")
+    end
+  end
+
+  context "doc exec COMMAND" do
+    let(:command) { ["exec", "bin/rspec", "-t", "spec/models/my_model_spec.rb"] }
+
+    it "executes the command in the container" do
+      expect(service).to receive(:exec).with("bin/rspec -t spec/models/my_model_spec.rb", { "environment" => "default" })
+      output
+    end
+
+    it "prints an error when environment variables are missing" do
+      expect(service).to receive(:exec).and_raise(Dockistrano::Service::EnvironmentVariablesMissing.new("error message"))
+      expect(output).to include("error message")
+    end
+  end
+
+  context "doc console" do
+    let(:command) { ["console"] }
+
+    it "starts a bash console in the container" do
+      expect(service).to receive(:console).with("/bin/bash", { "environment" => "default" })
+      output
+    end
+
+    it "prints an error when environment variables are missing" do
+      expect(service).to receive(:console).and_raise(Dockistrano::Service::EnvironmentVariablesMissing.new("error message"))
+      expect(output).to include("error message")
+    end
+  end
+
+  context "doc console COMMAND" do
+    let(:command) { ["console", "bin/rails console"] }
+
+    it "starts a console in the container" do
+      expect(service).to receive(:console).with("bin/rails console", { "environment" => "default" })
+      output
+    end
+
+    it "prints an error when environment variables are missing" do
+      expect(service).to receive(:console).and_raise(Dockistrano::Service::EnvironmentVariablesMissing.new("error message"))
+      expect(output).to include("error message")
+    end
+  end
+
+  context "doc clean" do
+    let(:command) { ["clean"] }
+
+    it "cleans the Docker instance and service dependency cache" do
+      expect(Dockistrano::Docker).to receive(:clean)
+      expect(Dockistrano::ServiceDependency).to receive(:clear_cache)
+      output
+    end
+  end
+
+  context "doc logs" do
+    let(:command) { ["logs"] }
+
+    it "attaches to the containers output when the container is running" do
+      expect(service).to receive(:running?).and_return(true)
+      expect(service).to receive(:attach)
+      expect(output).to include("Container application running, attaching to output")
+    end
+
+    it "prints the logs of the last run" do
+      expect(service).to receive(:running?).and_return(false)
+      expect(service).to receive(:logs)
+      expect(output).to include("Container application stopped, printing logs of last run")
+    end
+  end
+
+  context "doc logs NAME" do
+    let(:command) { ["logs", "postgresql"] }
+
+    it "attaches to the containers output when the container is running" do
+      expect(backing_service).to receive(:running?).and_return(true)
+      expect(backing_service).to receive(:attach)
+      expect(output).to include("Container postgresql running, attaching to output")
+    end
+
+    it "prints the logs of the last run" do
+      expect(backing_service).to receive(:running?).and_return(false)
+      expect(backing_service).to receive(:logs)
+      expect(output).to include("Container postgresql stopped, printing logs of last run")
+    end
+  end
+
+  context "doc ALIAS ARGUMENTS" do
+    let(:command) { ["rspec", "spec/models/my_model_spec.rb"] }
+
+    it "executes aliases that are defined in the configuration" do
+      allow(service).to receive(:config).and_return({ "aliases" => { "rspec" => "exec -e test bin/rspec" } })
+      expect(Kernel).to receive(:exec).with("doc exec -e test bin/rspec spec/models/my_model_spec.rb")
+      output
+    end
+  end
+
+end

data/spec/dockistrano/command_line_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Dockistrano::CommandLine do
+
+  subject { described_class }
+
+  context ".command_with_result" do
+    it "executes the command and returns a string with the result" do
+      expect(described_class.command_with_result("date")).to eq(`date`)
+    end
+  end
+
+  context ".command_with_stream" do
+    it "executes the command and returns a stream of output" do
+      expect(Kernel).to receive(:system).with("date").and_return(true)
+      expect(described_class.command_with_stream("date")).to be_true
+    end
+  end
+
+  context ".command_with_interaction" do
+    it "executes the command and returns a stream of output" do
+      expect(Kernel).to receive(:exec).with("date").and_return(true)
+      expect(described_class.command_with_interaction("date")).to be_true
+    end
+  end
+
+end

data/spec/dockistrano/docker_spec.rb

@@ -0,0 +1,242 @@
+require 'spec_helper'
+
+describe Dockistrano::Docker do
+
+  subject { described_class }
+
+  before do
+    ENV["DOCKER_BINARY"] = "docker"
+    ENV["DOCKER_HOST_IP"] = "127.0.0.1"
+  end
+
+  context ".docker_command" do
+    it "returns a string that allows us to call docker" do
+      ENV["DOCKER_BINARY"] = "/bin/docker"
+      ENV["DOCKER_HOST_IP"] = "127.0.0.1"
+      expect(subject.docker_command).to eq("/bin/docker -H 127.0.0.1")
+    end
+
+    it "raises an error when DOCKER_BINARY is not set" do
+      ENV["DOCKER_BINARY"] = nil
+      ENV["DOCKER_HOST_IP"] = "127.0.0.1"
+      expect { subject.docker_command }.to raise_error(Dockistrano::Docker::EnvironmentVariableMissing, /DOCKER_BINARY/)
+    end
+
+    it "raises an error when DOCKER_BINARY is not set" do
+      ENV["DOCKER_BINARY"] = "/bin/docker"
+      ENV["DOCKER_HOST_IP"] = nil
+      expect { subject.docker_command }.to raise_error(Dockistrano::Docker::EnvironmentVariableMissing, /DOCKER_HOST_IP/)
+    end
+  end
+
+  context ".ps" do
+    it "calls docker with the ps command" do
+      expect(subject).to receive(:execute).with(["ps", {}])
+      subject.ps
+    end
+  end
+
+  context ".stop" do
+    it "stops the container" do
+      expect(subject).to receive(:execute).with(["stop", "123456789"])
+      subject.stop("123456789")
+    end
+  end
+
+  context ".run" do
+    it "runs the default command when no command is given" do
+      expect(subject).to receive(:execute).with(["run", {e: "VAR=value"}, "registry/image:tag"])
+      subject.run("registry/image:tag", e: "VAR=value")
+    end
+
+    it "runs the default command when no command is given" do
+      expect(subject).to receive(:execute).with(["run", {e: "VAR=value"}, "registry/image:tag", "echo 'foobar'"])
+      subject.run("registry/image:tag", e: "VAR=value", command: "echo 'foobar'")
+    end
+  end
+
+  context ".exec" do
+    it "runs the default command when no command is given" do
+      expect(subject).to receive(:execute).with(["run", {e: "VAR=value"}, "registry/image:tag"], :stream)
+      subject.exec("registry/image:tag", e: "VAR=value")
+    end
+
+    it "runs the default command when no command is given" do
+      expect(subject).to receive(:execute).with(["run", {e: "VAR=value"}, "registry/image:tag", "echo 'foobar'"], :stream)
+      subject.exec("registry/image:tag", e: "VAR=value", command: "echo 'foobar'")
+    end
+  end
+
+  context ".console" do
+    it "runs the default command when no command is given" do
+      expect(subject).to receive(:execute).with(["run", { "e" => "VAR=value", "t" => true, "i" => true }, "registry/image:tag"], :interaction)
+      subject.console("registry/image:tag", "e" => "VAR=value")
+    end
+
+    it "runs the default command when no command is given" do
+      expect(subject).to receive(:execute).with(["run", { "e" => "VAR=value", "t" => true, "i" => true}, "registry/image:tag", "echo 'foobar'"], :interaction)
+      subject.console("registry/image:tag", "e" => "VAR=value", command: "echo 'foobar'")
+    end
+  end
+
+  context ".execute" do
+    it "calls docker and returns the result" do
+      expect(Dockistrano::CommandLine).to receive(:command_with_result).with("docker -H 127.0.0.1 version")
+      subject.execute(["version"])
+    end
+
+    it "adds options to the command" do
+      expect(Dockistrano::CommandLine).to receive(:command_with_result).with("docker -H 127.0.0.1 version -a")
+      subject.execute(["version", { a: true }])
+    end
+
+    it "adds array options to the command" do
+      expect(Dockistrano::CommandLine).to receive(:command_with_result).with("docker -H 127.0.0.1 version -a b -a c")
+      subject.execute(["version", { a: ["b", "c"] }])
+    end
+
+    it "calls docker and stream to stdout" do
+      expect(Dockistrano::CommandLine).to receive(:command_with_stream).with("docker -H 127.0.0.1 version")
+      subject.execute(["version"], :stream)
+    end
+
+    it "calls docker and takes over the console" do
+      expect(Dockistrano::CommandLine).to receive(:command_with_interaction).with("docker -H 127.0.0.1 version")
+      subject.execute(["version"], :interaction)
+    end
+  end
+
+  context ".running_container_id" do
+    it "returns the first id of a running container matching with the image name" do
+      stub_request(:get, "http://127.0.0.1:4243/containers/json").to_return(status: 200, body: '[{"Id":"8e319853f561ba2c22de2ec9ff2584f99d091dd20cc5b393ab874631c6993a36","Image":"registry.dev.provider.net/provider-app-2.0:develop","Command":"bin/provider webserver","Created":1382449380,"Status":"Up 24 hours","Ports":[{"PrivatePort":3000,"PublicPort":49225,"Type":"tcp"}],"SizeRw":0,"SizeRootFs":0},
+        {"Id":"107fc12c1c4b8e42091bd46e97c985d42c9e0d06506327e84f28fef585f9865a","Image":"registry.dev.provider.net/provider-app-2.0:develop","Command":"bin/provider worker","Created":1382449380,"Status":"Up 24 hours","Ports":[{"PrivatePort":3000,"PublicPort":49224,"Type":"tcp"}],"SizeRw":0,"SizeRootFs":0},
+        {"Id":"066474c539231e445c636dd6ef2879e6a3e304cead10f78bd79e385b161cbdf5","Image":"registry.dev.provider.net/hipache:develop","Command":"supervisord -n","Created":1382447352,"Status":"Up 24 hours","Ports":[{"PrivatePort":80,"PublicPort":80,"Type":"tcp"},{"PrivatePort":6379,"PublicPort":16379,"Type":"tcp"}],"SizeRw":0,"SizeRootFs":0}]')
+
+      expect(subject.running_container_id("registry.dev.provider.net/provider-app-2.0:develop")).to eq("8e319853f561ba2c22de2ec9ff2584f99d091dd20cc5b393ab874631c6993a36")
+    end
+  end
+
+  context ".last_run_container_id" do
+    it "returns the id of the previous run of the container" do
+      stub_request(:get, "http://127.0.0.1:4243/containers/json?all=1").to_return(status: 200, body: '[{"Id":"8e319853f561ba2c22de2ec9ff2584f99d091dd20cc5b393ab874631c6993a36","Image":"registry.dev.provider.net/provider-app-2.0:develop","Command":"cat /dockistrano.yml","Created":1382449380,"Status":"Up 24 hours","Ports":[{"PrivatePort":3000,"PublicPort":49225,"Type":"tcp"}],"SizeRw":0,"SizeRootFs":0},
+        {"Id":"107fc12c1c4b8e42091bd46e97c985d42c9e0d06506327e84f28fef585f9865a","Image":"registry.dev.provider.net/provider-app-2.0:develop","Command":"bin/provider worker","Created":1382449380,"Status":"Up 24 hours","Ports":[{"PrivatePort":3000,"PublicPort":49224,"Type":"tcp"}],"SizeRw":0,"SizeRootFs":0},
+        {"Id":"066474c539231e445c636dd6ef2879e6a3e304cead10f78bd79e385b161cbdf5","Image":"registry.dev.provider.net/hipache:develop","Command":"supervisord -n","Created":1382447352,"Status":"Up 24 hours","Ports":[{"PrivatePort":80,"PublicPort":80,"Type":"tcp"},{"PrivatePort":6379,"PublicPort":16379,"Type":"tcp"}],"SizeRw":0,"SizeRootFs":0}]')
+
+      expect(subject.last_run_container_id("registry.dev.provider.net/provider-app-2.0:develop")).to eq("107fc12c1c4b8e42091bd46e97c985d42c9e0d06506327e84f28fef585f9865a")
+    end
+  end
+
+  context ".image_id" do
+    it "returns the id of the image with the given name" do
+      expect(subject).to receive(:inspect_image).and_return({ "id" => "123456789" })
+      expect(subject.image_id("registry.dev/application:tag")).to eq("123456789")
+    end
+  end
+
+  context ".inspect_image" do
+    it "returns information about the image" do
+      stub_request(:get, "http://127.0.0.1:4243/images/123456789/json").to_return({
+        status: 200,
+        body: '{"id":"49f387cc90f2d5b82ded91c239b6e583f8b955cb532912cc959b1d1289b3f8f1","parent":"7735e8f30a47f02aa46732e864879fad0fb0b74230f7695b6235d6faf766dcb2","created":"2013-10-21T16:03:17.191097983+02:00","container":"5c2c523d3561d205f5459925325890bbf8054010cd908f61feed3e76520dcf54","container_config":{},"docker_version":"0.6.3","config":{},"architecture":"x86_64","Size":12288}'
+      })
+      expect(subject.inspect_image("123456789")).to include('id')
+    end
+
+    it "raises an error when the image is not found" do
+      stub_request(:get, "http://127.0.0.1:4243/images/123456789/json").to_return({
+        status: 404,
+        body: 'No such image: 123456789'
+      })
+
+      expect { subject.inspect_image("123456789") }.to raise_error(Dockistrano::Docker::ImageNotFound, /No such image: 123456789/)
+    end
+  end
+
+  context ".build" do
+    it "builds the container" do
+      expect(subject).to receive(:execute).with(["build", {t: "full_image_name"}, "."], :stream)
+      subject.build("full_image_name")
+    end
+  end
+
+  context ".pull" do
+    it "pulls the container with Docker" do
+      expect(subject).to receive(:execute).with(["pull", { t: "tag" }, "full_image_name"])
+      subject.pull("full_image_name", "tag")
+    end
+  end
+
+  context ".push" do
+    it "pushes the container with Docker" do
+      expect(subject).to receive(:execute).with(["push", "full_image_name", "tag"], :stream)
+      subject.push("full_image_name", "tag")
+    end
+  end
+
+  context ".logs" do
+    it "returns the logs for the container" do
+      expect(subject).to receive(:execute).with(["logs", "72819312"], :stream)
+      subject.logs("72819312")
+    end
+  end
+
+  context ".attach" do
+    it "attaches to the containers output" do
+      expect(subject).to receive(:execute).with(["attach", "72819312"], :stream)
+      subject.attach("72819312")
+    end
+  end
+
+  context ".inspect_container" do
+    it "returns information about the container" do
+      stub_request(:get, 'http://127.0.0.1:4243/containers/123456789/json').to_return({
+        status: 200,
+        body: '{"ID":"8e319853f561ba2c22de2ec9ff2584f99d091dd20cc5b393ab874631c6993a36","Created":"2013-10-22T15:43:00.213138644+02:00"}'
+      })
+
+      expect(subject.inspect_container("123456789")).to include("ID")
+    end
+  end
+
+  context ".clean" do
+    before do
+      allow(Dockistrano::CommandLine).to receive(:command_with_stream)
+      allow(subject).to receive(:docker_command).and_return("docker")
+    end
+
+    it "cleans images from the docker instance" do
+      expect(Dockistrano::CommandLine).to receive(:command_with_stream).with("docker rmi $(docker images -a | grep \"^<none>\" | awk '{print $3}')")
+      subject.clean
+    end
+
+    it "cleans containers from the docker instance" do
+      expect(Dockistrano::CommandLine).to receive(:command_with_stream).with("docker rm $(docker ps -a -q)")
+      subject.clean
+    end
+  end
+
+  context ".stop_all_containers_from_image" do
+    it "stops all containers from an image" do
+      stub_request(:get, "http://127.0.0.1:4243/containers/json").to_return(status: 200, body: '[{"Id":"8e319853f561ba2c22de2ec9ff2584f99d091dd20cc5b393ab874631c6993a36","Image":"registry.dev.provider.net/provider-app-2.0:develop","Command":"bin/provider webserver","Created":1382449380,"Status":"Up 24 hours","Ports":[{"PrivatePort":3000,"PublicPort":49225,"Type":"tcp"}],"SizeRw":0,"SizeRootFs":0},
+        {"Id":"107fc12c1c4b8e42091bd46e97c985d42c9e0d06506327e84f28fef585f9865a","Image":"registry.dev.provider.net/provider-app-2.0:develop","Command":"bin/provider worker","Created":1382449380,"Status":"Up 24 hours","Ports":[{"PrivatePort":3000,"PublicPort":49224,"Type":"tcp"}],"SizeRw":0,"SizeRootFs":0},
+        {"Id":"066474c539231e445c636dd6ef2879e6a3e304cead10f78bd79e385b161cbdf5","Image":"registry.dev.provider.net/hipache:develop","Command":"supervisord -n","Created":1382447352,"Status":"Up 24 hours","Ports":[{"PrivatePort":80,"PublicPort":80,"Type":"tcp"},{"PrivatePort":6379,"PublicPort":16379,"Type":"tcp"}],"SizeRw":0,"SizeRootFs":0}]')
+
+      expect(subject).to receive(:execute).with(["stop", "8e319853f561ba2c22de2ec9ff2584f99d091dd20cc5b393ab874631c6993a36"])
+      expect(subject).to receive(:execute).with(["stop", "107fc12c1c4b8e42091bd46e97c985d42c9e0d06506327e84f28fef585f9865a"])
+
+      subject.stop_all_containers_from_image("registry.dev.provider.net/provider-app-2.0:develop")
+    end
+  end
+
+  context ".tags_for_image" do
+    it "returns a list of tags for an image" do
+      stub_request(:get, "http://127.0.0.1:4243/images/json").to_return({
+        status: 200,
+        body: '[{"Repository":"registry.provider.net/application","Tag":"develop"},{"Repository":"registry.provider.net/application","Tag":"latest"},{"Repository":"registry.provider.net/memcached","Tag":"develop"}]'
+      })
+
+      expect(subject.tags_for_image("registry.provider.net/application")).to eq(["develop", "latest"])
+    end
+  end
+
+end

data/spec/dockistrano/git_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Dockistrano::Git do
+
+  context ".repository_name" do
+    let(:command) { double }
+
+    it "returns the name from a ssh remote" do
+      expect(Cocaine::CommandLine).to receive(:new).with("git config --get remote.origin.url").and_return(command)
+      expect(command).to receive(:run).and_return("git@github.com:username/reponame-with-2.0.git")
+
+      expect(described_class.repository_name).to eq("reponame-with-2.0")
+    end
+
+    it "returns the name from a ssh remote ending without .git" do
+      expect(Cocaine::CommandLine).to receive(:new).with("git config --get remote.origin.url").and_return(command)
+      expect(command).to receive(:run).and_return("git@github.com:username/reponame-with-2.0")
+
+      expect(described_class.repository_name).to eq("reponame-with-2.0")
+    end
+
+    it "returns the name from a https remote" do
+      expect(Cocaine::CommandLine).to receive(:new).with("git config --get remote.origin.url").and_return(command)
+      expect(command).to receive(:run).and_return("https://github.com/username/reponame-with-2.0")
+
+      expect(described_class.repository_name).to eq("reponame-with-2.0")
+    end
+
+  end
+
+  context ".branch" do
+    let(:command) { double }
+    it "returns the name of the branch" do
+      expect(Cocaine::CommandLine).to receive(:new).with("git rev-parse --abbrev-ref HEAD").and_return(command)
+      expect(command).to receive(:run).and_return("branch_name\n")
+
+      expect(described_class.branch).to eq("branch_name")
+    end
+
+    it "returns the JANKY_BRANCH env variable when available" do
+      ENV["JANKY_BRANCH"] = "feature/foobar"
+      expect(described_class.branch).to eq("feature-foobar")
+    end
+
+  end
+
+
+end