groove-ey-core 3.6.1

data/spec/database_server_snapshots_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "as a client" do
+  let(:client)    { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  context "with a database server" do
+    let!(:database_service) { create_database_service(provider: provider, client: client) }
+    let!(:database_server)  { database_service.servers.first }
+
+    it "should discover database server snapshots", :mock_only do
+      expect {
+        snapshots = client.database_server_snapshots.discover(provider).resource!
+        expect(snapshots).to be_a(Ey::Core::Client::DatabaseServerSnapshots)
+        expect(snapshots.count).not_to eq(0)
+      }.to change { database_server.snapshots.count }
+    end
+
+    it "creates a snapshot" do
+      snapshot = database_server.snapshots.create.resource!
+
+      expect(snapshot.database_server).to eq(database_server)
+      expect(snapshot.database_service).to eq(database_service)
+      expect(snapshot.provisioned_id).to be
+
+      expect(database_service.snapshots).to contain_exactly(snapshot)
+      expect(database_server.snapshots).to  contain_exactly(snapshot)
+    end
+
+    context "with a snapshot" do
+      let!(:snapshot) { database_server.snapshots.create.resource! }
+
+      it "destroys" do
+        expect {
+          snapshot.destroy!.resource!
+        }.to change { snapshot.reload.deleted_at }.from(nil)
+      end
+    end
+  end
+end

data/spec/database_server_usage_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+describe "server_usage", :mock_only do
+  let!(:client)      { create_client }
+  let!(:account)     { create_account(client: client, account: { owner: create_user(client: client)}) }
+  let!(:provider)    { create_provider(account: account) }
+  let!(:database_service)    { create_database_service(provider: provider) }
+
+  before(:each) do
+    client.find(:database_server_usages, account.id).merge!(
+      "2014-07" => [
+        {
+          "start_at"         => "2014-05-01T00:00:00+00:00",
+          "end_at"           => "2014-05-31T23:59:59+00:00",
+          "report_time"      => Time.now.iso8601,
+          "provisioned_id"   => "e982somedb",
+          "flavor"           => "db.r3.8xlarge",
+          "multi_az"         => false,
+          "master"           => false,
+          "location"         => "us-east-1d",
+          "database_service" => "https://api.engineyard.com/database_services/#{database_service.id}",
+          "provider"         => "https://api.engineyard.com/providers/#{provider.id}",
+        },
+      ]
+    )
+  end
+
+  it "can fetch usage for an account and billing_month" do
+    database_server_usages = client.database_server_usages.all(account_id: account.id, billing_month: "2014-07")
+
+    expect(database_server_usages.size).to eq(1)
+
+    database_server_usage = database_server_usages.first
+
+    expect(database_server_usage.start_at).not_to be_nil
+    expect(database_server_usage.end_at).not_to be_nil
+    expect(database_server_usage.report_time).not_to be_nil
+
+    expect(database_server_usage.provisioned_id).to   eq("e982somedb")
+    expect(database_server_usage.flavor).to   eq("db.r3.8xlarge")
+    expect(database_server_usage.multi_az).to eq(false)
+    expect(database_server_usage.master).to   eq(false)
+    expect(database_server_usage.location).to eq("us-east-1d")
+
+    expect(database_server_usage.database_service).to eq(database_service)
+    expect(database_server_usage.provider).to    eq(provider)
+  end
+
+end

data/spec/database_servers_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe "as a client" do
+  let(:client)    { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  context "with a database server" do
+    let!(:database_service) { create_database_service(provider: provider, client: client) }
+    let!(:database_server)  { database_service.servers.first }
+
+    it "should list the database server" do
+      expect(client.database_servers.all).to include(database_server)
+    end
+
+    context "and a bunch of others" do
+      let!(:_) { create_database_service }
+
+      it "should find a database server by provider" do
+        expect(client.database_servers.all(provider: provider.id)).to contain_exactly(database_server)
+      end
+    end
+
+    it "should add a message" do
+      message = nil
+
+      expect {
+        message = database_server.messages.create(message: Faker::Lorem.sentence(1))
+      }.to change { database_server.messages.size }.by(1)
+
+      expect(database_server.messages.first).to eq(message)
+    end
+
+    it "should create a replica" do
+      replica = client.database_servers.create!(provider: provider, replication_source: database_server).resource!
+
+      expect(client.database_servers.all).to include(replica)
+      expect(replica.replication_source).to  eq(database_server)
+      expect(replica.database_service).to    eq(database_server.database_service)
+      expect(replica.engine).to              eq(database_server.engine)
+      expect(replica.version).to             eq(database_server.version)
+      expect(replica.flavor).to              eq(database_server.flavor)
+      expect(replica.location).to            eq(database_server.location)
+      expect(replica.storage).to             eq(database_server.storage)
+      expect(replica.modifiers).to           eq(database_server.modifiers)
+      expect(replica.firewalls).not_to       be_nil
+
+      expect(database_service.reload.servers).to contain_exactly(database_server, replica)
+    end
+
+    it "should rediscover a database server and list its revisions", :mock_only do
+      expect {
+        database_server.discover.ready!
+      }.to change { database_server.reload.flavor }.and change { database_server.revisions.count }
+
+      revision = database_server.revisions.first
+      expect(revision.database_server).to eq(database_server)
+      expect(revision.data).to have_key("flavor")
+    end
+  end
+end

data/spec/database_services_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe "database services" do
+  let(:client)    { create_client }
+  let!(:account)  { create_account(client: client) }
+  let!(:provider) { create_provider(account: account) }
+
+  it "creates a database service" do
+    name     = Faker::Name.first_name
+    location = "us-west-2c"
+
+    database_service_params = Hashie::Mash.new(
+      :provider        => provider,
+      :name            => name,
+      :service_level   => 'self-service',
+      :database_server => {
+        :location  => location,
+        :flavor    => "db.m3.large",
+        :engine    => "postgres",
+        :version   => "9.3.5",
+        :modifiers => { :multi_az => true },
+      })
+
+    database_service = client.database_services.create!(database_service_params).resource!
+
+    expect(database_service.id).not_to be_nil
+    expect(database_service.name).to eq(database_service_params.name)
+    expect(database_service.provider).to eq(database_service_params.provider)
+    expect(database_service.servers.size).to eq(1)
+
+    server = database_service.servers.first
+    expect(server.provider).to       eq(provider)
+    expect(server.provisioned_id).to eq("#{name.downcase}master")
+    expect(server.location).to       eq(location)
+    expect(server.engine).to         eq(database_service_params.database_server.engine)
+    expect(server.version).to        eq(database_service_params.database_server.version)
+    expect(server.modifiers).to      eq(database_service_params.database_server.modifiers)
+    expect(server.endpoint).not_to   be_nil
+    expect(server.master?).to        be_truthy
+
+    firewall = client.firewalls.last
+    expect(server.firewalls).to  contain_exactly(firewall)
+    expect(firewall.location).to eq("us-west-2")
+    expect(firewall.provider).to eq(provider)
+  end
+
+  context "with a database service" do
+    let!(:database_service) { create_database_service(provider: provider, client: client) }
+    let!(:logical_database) { create_logical_database(client: client, database_service: database_service) }
+
+    it "destroys a database service" do
+
+      firewall = database_service.servers.first.firewalls.first
+
+      expect {
+        database_service.destroy.ready!
+      }.to change  { database_service.reload.deleted_at }.from(nil).
+        and change { client.database_servers.size }.by(-database_service.servers.size).
+        and change { client.logical_databases.size }.by(-database_service.databases.size).
+        and change { firewall.reload.deleted_at }.from(nil)
+    end
+
+    it "shows the environment's database service in an environment" do
+      environment_database_service, environment = load_blueprint
+
+      expect(environment.database_service).to eq(environment_database_service)
+    end
+
+
+    it 'lists database services in an account' do
+      environment_database_service, environment = load_blueprint
+
+      expect(client.database_services.all(account: environment.account.id).map(&:id)).to include(environment_database_service.id)
+    end
+  end
+end

data/spec/deployments_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe "deployments" do
+  let!(:client) { create_client }
+  let!(:account) { create_account(client: client) }
+  let!(:application) { create_application(account: account) }
+  let!(:environment) { create_environment(account: account, application: application, name: Faker::Name.first_name) }
+
+  before(:each) { environment.deploy(application, ref: "HEAD").resource! }
+
+  it "lists deployments" do
+    expect(environment.deployments).not_to be_empty
+    deployment = environment.deployments.first
+    expect(deployment.reload).to be
+  end
+
+  it "times out a deployment" do
+    deployment = environment.deployments.first
+
+    expect {
+      deployment.timeout
+    }.to change { deployment.reload.successful }.to(false)
+  end
+end

data/spec/docker_registry_credentials_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let(:client) { create_client }
+  let(:location) { 'us-east-1' }
+  let!(:account) { create_account(client: client) }
+
+  it 'returns a valid docker registry credentials' do
+    credentials = account.retrieve_docker_registry_credentials(location)
+
+    expect(credentials.username).to be
+    expect(credentials.password).to be
+    expect(credentials.registry_endpoint).to match(/#{location}/)
+    expect(credentials.expires_at).to be > (Time.now + 6 * 3600).to_i
+  end
+end

data/spec/environment_plan_usage_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+
+describe "plan_usage", :mock_only do
+  let!(:client)  { create_client }
+  let!(:account) { create_account(client: client, account: { owner: create_user(client: client)}) }
+  let!(:environment) { create_environment(account: account) }
+
+  before(:each) do
+    client.find(:environment_plan_usages, account.id).merge!(
+      "2014-07" => [
+        {
+          "start_at"      => "2014-05-01T00:00:00+00:00",
+          "end_at"        => "2014-05-31T23:59:59+00:00",
+          "report_time"   => Time.now.iso8601,
+          "type"          => "self-service-00",
+          "environment" => "https://api.engineyard.com/environments/#{environment.id}",
+        },
+      ]
+    )
+  end
+
+  it "can fetch plan usage for an account and billing_month" do
+    environment_plan_usages = client.environment_plan_usages.all(account_id: account.id, billing_month: "2014-07")
+
+    expect(environment_plan_usages.size).to eq(1)
+
+    environment_plan_usage = environment_plan_usages.first
+
+    expect(environment_plan_usage.start_at).not_to be_nil
+    expect(environment_plan_usage.end_at).not_to be_nil
+    expect(environment_plan_usage.report_time).not_to be_nil
+
+    expect(environment_plan_usage.type).to eq("self-service-00")
+
+    expect(environment_plan_usage.environment).to eq(environment)
+  end
+
+end

data/spec/environments_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let(:client) { create_client }
+
+  context "with an account" do
+    let!(:account)  { create_account(client: client) }
+    let!(:provider) { create_provider(account: account) }
+    let!(:app)      { create_application(account: account, client: client) }
+
+    it "does not create an environment without an application" do
+      expect {
+        client.environments.create!(name: Faker::Name.first_name, account: account)
+      }.to raise_error(ArgumentError)
+    end
+
+    it "creates an environment" do
+      name = Faker::Name.first_name
+
+      environment = create_environment(account: account, application: app, environment: {name: name}, boot: false)
+      expect(environment.name).to eq(name)
+      expect(environment.classic).to eq(true)
+    end
+
+    context "with a database service" do
+      let(:database_service) { create_database_service(provider: provider) }
+
+      it "creates an environment with a logical database" do
+        name = SecureRandom.hex(4)
+        expect {
+          create_environment(account: account, application: app, database_service: database_service, environment: {name: name})
+        }.to change { account.environments.count }.by(1).and change { client.logical_databases.count }.by(1)
+
+        environment      = client.environments.first(name: name)
+        expect(environment.logical_databases.count).to eq(1)
+        logical_database = environment.logical_databases.first
+        expect(logical_database.name).to eq("#{environment.name}_#{app.name}")
+      end
+    end
+
+    context "alerting environments", :mock_only do
+      let(:legacy_alert)         { client.legacy_alerts.get(1001) }
+      let(:server)               { client.servers.first }
+      let(:alerting_environment) { create_environment(account: account, application: app, environment: { name: Faker::Name.first_name}) }
+      let(:other_environment)    { create_environment(enviroment: { name: Faker::Name.first_name}, application: app, account: account) }
+
+      before do
+        create_server(client,
+                       provisioned_id: "i-a1000fce",
+                             provider: provider,
+                          environment: alerting_environment,
+                                state: "running")
+
+        create_legacy_alert(client,
+                                type: "cpu",
+                            severity: "warning",
+                              server: server,
+                        acknowledged: false)
+      end
+
+      it "lists alerting environments" do
+        environments = client.environments.alerting
+        expect(environments).to include(alerting_environment)
+        expect(environments).not_to include(other_environment)
+      end
+
+      context "and the environment is permanently ignored", mock_only: true do
+        before(:each) do
+          client.data[:environments][alerting_environment.id]["permanently_ignored"] = true
+        end
+
+        it "returns the ignored environment by default" do
+          expect(client.environments.alerting).to contain_exactly(alerting_environment)
+        end
+
+        it "filters it if you tell it to" do
+          expect(client.environments.alerting("exclude_ignored" => true)).to be_empty
+        end
+      end
+    end
+
+    context "with an environment" do
+      let!(:name)        { Faker::Name.first_name }
+      let!(:environment) { create_environment(account: account, application: app, environment: {name: name}, configuration: {type: "production"}) }
+
+      describe '#assignee' do
+        let(:assignee) {client.environments.get(environment.id).assignee}
+
+        context 'for an environment with an assignee' do
+          let(:user) {create_user(client: client, creator: client)}
+
+          before(:each) do
+            # Since we can't set an assignee directly ...
+            client.data[:environments][environment.id]['assignee_id'] = user.id
+          end
+
+          it 'is the user assigned to the environment' do
+            expect(assignee).to eql(user)
+          end
+        end
+
+        context 'for an environment without an assignee' do
+          it 'is nil' do
+            expect(assignee).to be_nil
+          end
+        end
+      end
+
+      describe '#unassign!' do
+        let(:user) {create_user(client: client, creator: client)}
+
+        let(:test_env) {account.environments.get(environment.id)}
+
+        before(:each) do
+          # Since we can't set an assignee directly ...
+          client.data[:environments][environment.id]['assignee_id'] = user.id
+        end
+
+        it 'removes the assignment from the environment' do
+          expect(test_env.assignee).not_to be_nil
+
+          test_env.unassign!
+
+          expect(test_env.assignee).to be_nil
+        end
+      end
+
+      it "has the right number of servers" do
+        expect(environment.servers.count).to eq(5)
+      end
+
+      it "creates a blueprint" do
+        blueprint = nil
+        expect {
+          blueprint = environment.save_blueprint("name" => SecureRandom.hex(3))
+        }.to change { environment.blueprints.count }.by(1)
+
+        expect(blueprint.data["app_instances"].count).to eq(3)
+        expect(blueprint.data["db_master"].count).to eq(1)
+        expect(blueprint.data["db_slaves"].count).to eq(1)
+      end
+
+      it "applies main" do
+        expect(environment.apply.ready!).to be_successful
+
+        if Ey::Core::Client.mocking?
+          expect(client.data[:instance_updates].count).to eq(environment.servers.count)
+          expect(client.data[:instance_updates].values.map { |iu| iu["data"]["type"] }).to eq(["main"] * environment.servers.count)
+        end
+      end
+
+      it "applies custom" do
+        expect(environment.apply("custom").ready!).to be_successful
+
+        if Ey::Core::Client.mocking?
+          expect(client.data[:instance_updates].count).to eq(environment.servers.count)
+          expect(client.data[:instance_updates].values.map { |iu| iu["data"]["type"] }).to eq(["custom"] * environment.servers.count)
+        end
+      end
+
+      it "destroys an environment" do
+        expect {
+          environment.destroy.ready!
+        }.to change { environment.reload.deleted_at }.from(nil)
+      end
+
+      it "searches for enviornment by name" do
+        expect(client.environments.all(name: name).size).to eq(1)
+        expect(client.environments.first(name: name)).to eq(environment)
+      end
+
+      it "gets an account's environments" do
+        expect(account.environments.all.map(&:identity)).to contain_exactly(environment.identity)
+      end
+
+      it 'gets the environment attributes' do
+        expect(client.environments.get(environment.id)).to have_attributes(
+          "account"               => account,
+          "classic"               => true,
+          "custom_recipes"        => nil,
+          "database_stack"        => "postgres9_4",
+          "deployments_url"       => client.url_for("/environments/#{environment.id}/deployments"),
+          "id"                    => environment.id,
+          "keypairs"              => environment.keypairs,
+          "logical_databases_url" => client.url_for("/environments/#{environment.id}/logical-databases"),
+          "release_label"         => "stable-v4-2.0.101",
+          "servers"               => environment.servers,
+          "stack_name"            => "nginx_passenger4",
+          "username"              => "deploy",
+          "service_level"         => "default"
+        )
+      end
+
+      it "adds a keypair" do
+        client.keypairs.create(name: SecureRandom.hex(6), public_key: SSHKey.generate.ssh_public_key)
+      end
+
+      it "deploys the application" do
+        environment.deploy(app, ref: "HEAD").resource! # dont explode
+      end
+    end
+
+    context "with multiple environments" do
+      it "should list all environments"
+    end
+  end
+
+  context "with multiple accounts" do
+    it "should list all environments"
+    it "should list an account's environments"
+  end
+end