ey-core 3.0.0

data/spec/costs_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe 'Costs' do
+  let(:client)   { create_client }
+  let!(:account) { create_account(client: client) }
+
+  it 'should return an empty array with no costs' do
+    expect(account.costs.all).to be_empty
+  end
+
+  it 'should get costs for an account', :mock_only do
+    create_cost(client, account: account)
+    expect(account.costs.all).not_to be_empty
+  end
+
+  it 'should search costs', :mock_only do
+    create_cost(client, account: account, level: 'total')
+    create_cost(client, account: account, level: 'summarized')
+    costs = account.costs.select { |c| c.level == 'total' }
+    expect(costs.first.level).to eq 'total'
+  end
+end

data/spec/database_plan_usage_spec.rb

@@ -0,0 +1,39 @@
+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!(:provider)    { create_provider(account: account) }
+  let!(:database_service)    { create_database_service(provider: provider) }
+
+  before(:each) do
+    client.find(:database_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",
+          "database_service" => "https://api.engineyard.com/database_services/#{database_service.id}",
+        },
+      ]
+    )
+  end
+
+  it "can fetch plan usage for an account and billing_month" do
+    database_plan_usages = client.database_plan_usages.all(account_id: account.id, billing_month: "2014-07")
+
+    expect(database_plan_usages.size).to eq(1)
+
+    database_plan_usage = database_plan_usages.first
+
+    expect(database_plan_usage.start_at).not_to be_nil
+    expect(database_plan_usage.end_at).not_to be_nil
+    expect(database_plan_usage.report_time).not_to be_nil
+
+    expect(database_plan_usage.type).to eq("self-service-00")
+
+    expect(database_plan_usage.database_service).to eq(database_service)
+  end
+
+end

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/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,106 @@
+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
+        pending "adding servers to environments not yet implemented"
+        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
+    end
+
+    context "with an environment" do
+      let!(:name)        { Faker::Name.first_name }
+      let!(:environment) { create_environment(account: account, application: app, environment: {name: name}) }
+
+      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 "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

data/spec/features_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe 'as a user' do
+  let!(:client) { create_client }
+
+  let!(:public_feature) do
+    if Ey::Core::Client.mocking?
+      client.create_feature(
+                     :id      => "public_feature",
+                     :privacy => "public",
+                     :name    => "A Public Feature",
+                    )
+    else
+      client.features.all.first
+    end
+  end
+
+  let!(:other_feature)  do
+    if Ey::Core::Client.mocking?
+      client.create_feature(
+                     :id      => "other_feature",
+                     :privacy => "private",
+                     :name    => "Another Feature",
+                    )
+    else
+      client.features.all.last
+    end
+  end
+
+  context "with an account" do
+    let!(:account) { create_account(client: client) }
+
+    it "should list account features" do
+      client.features.get(other_feature.identity).enable!(account)
+
+      expect(account.features.all.size).to be > 0
+
+      feature = account.features.first(id: other_feature.id)
+
+      expect(feature.id).to          eq(other_feature.id)
+      expect(feature.name).to        eq(other_feature.name)
+      expect(feature.description).to eq(other_feature.description)
+    end
+
+    it "should enable feature" do
+      expect {
+        client.features.first.enable!(account)
+      }.to change { account.features.all.size }.by(1)
+    end
+
+    it "should disable feature" do
+      client.features.first.enable!(account)
+      expect {
+        client.features.first.disable!(account)
+      }.to change { account.features.all.size }.by(-1)
+    end
+  end
+
+  context "without an account" do
+    it "should list features" do
+      expect(client.features.all).to include(public_feature)
+    end
+
+    it "should show a feature" do
+      feature = client.features.get(public_feature.identity)
+
+      expect(feature).not_to be_nil
+
+      expect(feature.id).to          eq(public_feature.identity)
+      expect(feature.name).to        eq(public_feature.name)
+      expect(feature.description).to eq(public_feature.description)
+    end
+  end
+
+  context "with multiple accounts" do
+    it "should list all enabled features"
+    it "should list an account's enabled features"
+  end
+end