ufo 5.0.6 → 6.0.1

data/spec/lib/setting_spec.rb

@@ -1,18 +0,0 @@
-describe Ufo::Setting do
-  before(:all) do
-    create_ufo_project
-  end
-
-  let(:setting) { Ufo::Setting.new }
-
-  it "includes the cluster setting" do
-    puts "Ufo.env #{Ufo.env}"
-    cluster = setting.data[:cluster]
-    expect(cluster).to eq "dev"
-  end
-
-  it "ufo_env" do
-    ufo_env = setting.ufo_env
-    expect(ufo_env).to eq "development"
-  end
-end

data/spec/lib/ship_spec.rb

@@ -1,46 +0,0 @@
-describe Ufo::Ship do
-  let(:options) do
-    {
-      noop: true,
-      mute: true,
-      wait: false,
-      task_definition: service,
-      stop_old_tasks: false,
-    }
-  end
-  let(:service) { "demo-web-prod" }
-  let(:ship) do
-    ship = Ufo::Ship.new(service, options)
-    allow(ship).to receive(:ecs).and_return(ecs_client)
-    ship
-  end
-
-  context "demo-web-prod service" do
-    it "should create or update service" do
-      allow(ship).to receive(:deploy_stack)
-
-      ship.deploy
-
-      expect(ship).to have_received(:deploy_stack)
-    end
-  end
-
-  # mocks
-  def ecs_client
-    ecs = double("ecs")
-    allow(ecs).to receive(:describe_clusters).and_return(ecs_describe_clusters)
-    ecs
-  end
-
-  # ensure_cluster_exist calls this and this makes sure that the cluster 'exists'
-  def ecs_describe_clusters
-    describe_clusters = double("ecs-describe-clusters")
-    cluster1 = OpenStruct.new(status: "ACTIVE")
-    allow(describe_clusters).to receive(:clusters).and_return([cluster1])
-    describe_clusters
-  end
-
-  def ecs_service(name)
-    OpenStruct.new(service_name: name)
-  end
-end

data/spec/lib/stack/status_spec.rb

@@ -1,76 +0,0 @@
-describe Ufo::Stack::Status do
-  let(:status) do
-    status = Ufo::Stack::Status.new(stack_name: "test-web")
-    allow(status).to receive(:cloudformation).and_return(cloudformation)
-    status
-  end
-  let(:cloudformation) do
-    service = double("service").as_null_object
-    allow(service).to receive(:describe_stacks).and_return(stack_status)
-    allow(service).to receive(:describe_stack_events).and_return(stack_events)
-    service
-  end
-
-  context "in progress" do
-    let(:stack_status) { "UPDATE_IN_PROGRESS" }
-    let(:stack_events) { JSON.load(IO.read("spec/fixtures/cfn/stack-events-in-progress.json")) }
-    it "lists events since user initiated event" do
-      status.refresh_events
-      i = status.find_index(:start)
-      expect(i).to eq 15
-      # uncomment to view and debug
-      # status.show_events
-      # puts "****"
-      # status.show_events # show not show anything
-    end
-
-    it "lists events since last shown event" do
-      # first display
-      status.refresh_events
-      i = status.find_index(:start)
-      expect(i).to eq 15
-
-      # move the last event back in time 4 events, so should print 3 events
-      status.instance_variable_set(:@last_shown_event_id, "TargetGroup-ec634c43-b887-4bde-a525-7c69782865a6")
-
-      captured_events = []
-      allow(status).to receive(:print_event) do |e|
-        captured_events << "#{e["resource_type"]} #{e["resource_status"]}"
-      end
-      status.show_events
-      expect(captured_events).to eq([
-        "AWS::ElasticLoadBalancingV2::LoadBalancer DELETE_IN_PROGRESS",
-        "AWS::ElasticLoadBalancingV2::LoadBalancer DELETE_COMPLETE",
-        "AWS::EC2::SecurityGroup DELETE_IN_PROGRESS",
-      ])
-    end
-  end
-
-  context "complete" do
-    let(:stack_status) { "UPDATE_COMPLETE" }
-    let(:stack_events) { JSON.load(IO.read("spec/fixtures/cfn/stack-events-complete.json")) }
-    it "lists events all the way to completion" do
-      status.refresh_events
-      i = status.find_index(:start)
-      expect(i).to eq 17
-      # uncomment to view and debug
-      # status.show_events
-    end
-  end
-
-  context "update_rollback" do
-    let(:stack_status) { "UPDATE_ROLLBACK_COMPLETE" }
-    let(:stack_events) { JSON.load(IO.read("spec/fixtures/cfn/stack-events-update-rollback-complete.json")) }
-    it "lists events all the way to update rollback complete" do
-      status.refresh_events
-      expect(status.success?).to be false
-      expect(status.update_rollback?).to be true
-      expect(status.rollback_error_message).to include("STATIC_NAME")
-
-      # i = status.find_index(:start)
-      # expect(i).to eq 17
-      # uncomment to view and debug
-      # status.show_events
-    end
-  end
-end

data/spec/lib/stop_spec.rb

@@ -1,13 +0,0 @@
-describe Ufo::Stop do
-  before(:all) do
-    create_ufo_project
-  end
-  let(:stop) { Ufo::Stop.new("test-web") }
-  let(:deployments) { JSON.load(IO.read("spec/fixtures/deployments.json")) }
-
-  it "stop" do
-    stop.instance_variable_set(:@deployments, deployments)
-    arn = stop.latest_deployed_arn
-    expect(arn).to include "demo-web:91"
-  end
-end

data/spec/lib/task_spec.rb

@@ -1,54 +0,0 @@
-describe Ufo::Task do
-  before(:each) do
-    create_ufo_project
-  end
-  let(:options) do
-    {
-      mute: true
-    }
-  end
-  let(:task_definition) { "hi-migrate-prod" }
-
-  context "hi-migrate-prod" do
-    it "should migrate the database" do
-      task.run
-
-      expect(task.ecs).to have_received(:run_task)
-    end
-
-    it "should wait for the command to finish" do
-      expect do
-        task(wait: true, timeout: 600).run
-        expect(task.ecs).to have_received(:run_task)
-      end.to raise_error(SystemExit) do |error|
-        expect(error.status).to eq(5)
-      end
-    end
-  end
-
-  # mocks
-  def ecs_client
-    ecs = double("ecs")
-    ecs_container = double("ecs_container")
-    fake_response = double('fake-response').as_null_object
-    allow(ecs).to receive(:run_task).and_return(fake_response)
-    allow(ecs).to receive(:wait_until).and_return(fake_response)
-    allow(ecs).to receive(:describe_tasks).and_return(OpenStruct.new({
-      tasks: [OpenStruct.new(containers: [ecs_container])]
-    }))
-    allow(ecs).to receive(:list_task_definitions).and_return(fake_response)
-    allow(ecs).to receive(:describe_task_definition).and_return(fake_response)
-    allow(ecs_container).to receive(:exit_code).and_return(5)
-    ecs
-  end
-
-  def task option_overwrites = {}
-    @task ||=
-      begin
-        task = Ufo::Task.new(task_definition, options.merge(option_overwrites))
-        allow(task).to receive(:ensure_log_group_exist) # stub not so not called
-        allow(task).to receive(:ecs).and_return(ecs_client)
-        task
-      end
-  end
-end