Top Level Namespace

Defined Under Namespace

Modules: Miasma

Constant Summary

MIASMA_COMPUTE_ABSTRACT =

-> {

  # Required `let`s:
  # * compute: compute API
  # * build_args: server build arguments [Smash]

  describe Miasma::Models::Compute, :vcr do
    it "should provide #servers collection" do
      compute.servers.must_be_kind_of Miasma::Models::Compute::Servers
    end

    describe Miasma::Models::Compute::Servers do
      it "should provide instance class used within collection" do
        compute.servers.model.must_equal Miasma::Models::Compute::Server
      end

      it "should build new instance for collection" do
        instance = compute.servers.build(:name => "test")
        instance.must_be_kind_of Miasma::Models::Compute::Server
      end

      it "should provide #all servers" do
        compute.servers.all.must_be_kind_of Array
      end
    end

    describe Miasma::Models::Compute::Server do
      before do
        unless $miasma_instance
          VCR.use_cassette("Miasma_Models_Compute_Global/GLOBAL_compute_instance_create") do
            @instance = compute.servers.build(build_args)
            @instance.save
            until @instance.state == :running
              miasma_spec_sleep
              @instance.reload
            end
            $miasma_instance = @instance
          end
          Kernel.at_exit do
            VCR.use_cassette("Miasma_Models_Compute_Global/GLOBAL_compute_instance_destroy") do
              $miasma_instance.destroy
            end
          end
        else
          @instance = $miasma_instance
        end
        @instance.reload
      end

      let(:instance) { @instance }

      describe "instance methods" do
        it "should have a name" do
          instance.name.must_equal build_args[:name]
        end

        it "should have an image_id" do
          instance.image_id.must_equal build_args[:image_id]
        end

        it "should have a flavor_id" do
          instance.flavor_id.must_equal build_args[:flavor_id]
        end

        it "should have an address" do
          instance.addresses.detect do |addr|
            addr.version == 4
          end.address.must_match /^(\d+)+\.(\d+)\.(\d+)\.(\d+)$/
        end

        it "should have a status" do
          instance.status.wont_be_nil
        end

        it "should be in :running state" do
          instance.state.must_equal :running
        end
      end
    end

    describe "instance lifecycle" do
      it "should create new server, reload details and destroy server" do
        instance = compute.servers.build(build_args)
        instance.save
        instance.id.wont_be_nil
        instance.state.must_equal :pending
        compute.servers.reload.get(instance.id).wont_be_nil
        until instance.state == :running
          miasma_spec_sleep
          instance.reload
        end
        instance.state.must_equal :running
        instance.destroy
        while instance.state == :running
          miasma_spec_sleep
          instance.reload
        end
        [:pending, :terminated].must_include instance.state
        if instance.state == :pending
          until instance.state == :terminated
            miasma_spec_sleep
            instance.reload
          end
          instance.state.must_equal :terminated
        end
      end
    end
  end
}

MIASMA_STORAGE_ABSTRACT =

-> {

  # Required `let`s:
  # * storage: storage API

  describe Miasma::Models::Storage, :vcr do
    it "should provide #buckets collection" do
      storage.buckets.must_be_kind_of Miasma::Models::Storage::Buckets
    end

    describe Miasma::Models::Storage::Buckets do
      it "should provide instance class used within collection" do
        storage.buckets.model.must_equal Miasma::Models::Storage::Bucket
      end

      it "should build new instance for collection" do
        storage.buckets.build.must_be_kind_of Miasma::Models::Storage::Bucket
      end

      it "should provide #all buckets" do
        storage.buckets.all.must_be_kind_of Array
      end
    end

    describe Miasma::Models::Storage::Bucket do
      it "should act like a bucket" do
        bucket = storage.buckets.build(:name => "miasma-test-bucket-010")
        bucket.save
        bucket.reload

        # should include the bucket
        storage.buckets.reload.get("miasma-test-bucket-010").wont_be_nil
        # should have a name
        bucket.name.must_equal "miasma-test-bucket-010"
        # should have a #files collection
        bucket.files.must_be_kind_of Miasma::Models::Storage::Files
        #should provide #all files
        bucket.files.all.must_be_kind_of Array
        # should include reference to containing bucket
        bucket.files.bucket.must_equal bucket
        # should build new instance for collection
        bucket.files.build.must_be_kind_of Miasma::Models::Storage::File

        file_content = "blahblahblah"
        file = bucket.files.build
        file.name = "miasma-test-file"
        file.body = file_content
        file.save
        file.reload

        # should have a name
        file.name.must_equal "miasma-test-file"
        # should have a size
        file.size.must_equal file_content.size
        # should have an updated timestamp
        file.updated.must_be_kind_of Time
        # should create a valid url
        open(file.url).read.must_equal file_content
        # should have a body
        file.body.must_respond_to :readpartial
        file.body.readpartial(Miasma::Models::Storage::READ_BODY_CHUNK_SIZE).must_equal file_content
        file.destroy

        big_file_content = "*" * Miasma::Models::Storage::MAX_BODY_SIZE_FOR_STRINGIFY
        big_file = bucket.files.build
        big_file.name = "miasma-test-file-big"
        big_file.body = big_file_content
        big_file.save
        big_file.reload

        # should be the correct size
        big_file.size.must_equal big_file.size
        # should provide streaming body
        big_file.body.must_respond_to :readpartial
        content = big_file.body.readpartial(big_file.size)
        content.must_equal big_file_content
        big_file.destroy

        require "tempfile"
        local_io_file = Tempfile.new("miasma-storage-test")
        big_io_content = "*" * (Miasma::Models::Storage::MAX_BODY_SIZE_FOR_STRINGIFY * 1.3)
        local_io_file.write big_io_content
        local_io_file.flush
        local_io_file.rewind
        remote_file = bucket.files.build
        remote_file.name = "miasma-test-io-object-010"
        remote_file.body = local_io_file
        remote_file.save
        remote_file.reload

        # should be the correct size
        remote_file.size.must_equal local_io_file.size
        # should provide streaming body
        remote_file.body.must_respond_to :readpartial
        content = ""
        while chunk = remote_file.body.readpartial(1024)
          content << chunk
        end
        content.must_equal big_io_content
        remote_file.destroy
        bucket.destroy
      end
    end
  end
}

MIASMA_LOAD_BALANCER_ABSTRACT =

-> {

  # Required `let`s:
  # * load_balancer: load balancer API
  # * build_args: load balancer build arguments [Smash]

  describe Miasma::Models::LoadBalancer, :vcr do
    it "should provide #balancers collection" do
      load_balancer.balancers.must_be_kind_of Miasma::Models::LoadBalancer::Balancers
    end

    describe Miasma::Models::LoadBalancer::Balancers do
      it "should provide instance class used within collection" do
        load_balancer.balancers.model.must_equal Miasma::Models::LoadBalancer::Balancer
      end

      it "should build new instance for collection" do
        instance = load_balancer.balancers.build
        instance.must_be_kind_of Miasma::Models::LoadBalancer::Balancer
      end

      it "should provide #all balancers" do
        load_balancer.balancers.all.must_be_kind_of Array
      end
    end

    describe Miasma::Models::LoadBalancer::Balancer do
      before do
        unless $miasma_balancer
          VCR.use_cassette("Miasma_Models_LoadBalancer_Global/GLOBAL_load_balancer_create") do
            @balancer = load_balancer.balancers.build(build_args)
            @balancer.save
            until @balancer.state == :active
              miasma_spec_sleep
              @balancer.reload
            end
            $miasma_balancer = @balancer
          end
          Kernel.at_exit do
            VCR.use_cassette("Miasma_Models_LoadBalancer_Global/GLOBAL_load_balancer_destroy") do
              $miasma_balancer.destroy
            end
          end
        else
          @balancer = $miasma_balancer
        end
        @balancer.reload
      end

      let(:balancer) { @balancer }

      describe "collection" do
        it "should include balancer" do
          load_balancer.balancers.reload.get(balancer.id).wont_be_nil
        end
      end

      describe "balancer methods" do
        it "should have a name" do
          balancer.name.must_equal build_args[:name]
        end

        it "should be in :active state" do
          balancer.state.must_equal :active
        end

        it "should have a status" do
          balancer.status.wont_be_nil
          balancer.status.must_be_kind_of String
        end

        it "should have a public address" do
          balancer.public_addresses.wont_be :empty?
        end
      end
    end
  end
}

MIASMA_ORCHESTRATION_ABSTRACT =

-> {

  # Required `let`s:
  # * orchestration: orchestration API
  # * build_args: stack build arguments [Smash]

  describe Miasma::Models::Orchestration, :vcr do
    it "should provide #stacks collection" do
      orchestration.stacks.must_be_kind_of Miasma::Models::Orchestration::Stacks
    end

    describe Miasma::Models::Orchestration::Stacks do
      it "should provide instance class used within collection" do
        orchestration.stacks.model.must_equal Miasma::Models::Orchestration::Stack
      end

      it "should build new instance for collection" do
        instance = orchestration.stacks.build
        instance.must_be_kind_of Miasma::Models::Orchestration::Stack
      end

      it "should provide #all stacks" do
        orchestration.stacks.all.must_be_kind_of Array
      end
    end

    describe Miasma::Models::Orchestration::Stacks do
      before do
        unless $miasma_stack
          VCR.use_cassette("Miasma_Models_Orchestration_Global/GLOBAL_orchestration_stack_create") do
            @stack = orchestration.stacks.build(build_args)
            @stack.save
            Timeout.timeout(500) do
              until @stack.state == :create_complete
                miasma_spec_sleep
                @stack.reload
              end
            end
            @stack.template
            orchestration.stacks.reload
            $miasma_stack = @stack
          end
          Kernel.at_exit do
            VCR.use_cassette("Miasma_Models_Compute_Global/GLOBAL_orchestration_stack_destroy") do
              $miasma_stack.destroy
            end
          end
        else
          @stack = $miasma_stack
        end
        @stack.reload
      end

      let(:stack) { @stack }

      describe "collection" do
        it "should include stack" do
          orchestration.stacks.all.detect { |s| s.id == stack.id }.wont_be_nil
          orchestration.stacks.get(stack.id).wont_be_nil
        end
      end

      describe "instance methods" do
        it "should have a name" do
          stack.name.must_equal build_args[:name]
        end

        it "should be in :create_complete state" do
          stack.state.must_equal :create_complete
        end

        it "should have a status" do
          stack.status.must_be_kind_of String
        end

        it "should have a creation time" do
          stack.created.must_be_kind_of Time
        end

        it "should have parameters used for creation" do
          stack.parameters.to_smash.must_equal build_args[:parameters].to_smash
        end

        it "should include the templated used for creation" do
          stack.template.to_smash.must_equal build_args[:template].to_smash
        end
      end
    end

    describe "instance lifecycle" do
      it "should create new stack, reload details and destroy stack" do
        stack = orchestration.stacks.build(build_args.merge(:name => "miasma-test-stack-2"))
        stack.save
        stack.id.wont_be_nil
        stack.state.must_equal :create_in_progress
        orchestration.stacks.reload.get(stack.id).wont_be_nil
        until stack.state == :create_complete
          miasma_spec_sleep
          stack.reload
        end
        stack.state.must_equal :create_complete
        stack.destroy
        [:delete_in_progress, :delete_complete].must_include stack.state
        Timeout.timeout(500) do
          until stack.state == :delete_complete
            miasma_spec_sleep
            stack.reload
          end
        end
        stack.state.must_equal :delete_complete
      end
    end
  end
}

Instance Method Summary

• #miasma_spec_sleep(interval = 20) ⇒ Object

Instance Method Details

#miasma_spec_sleep(interval = 20) ⇒ Object

# File 'lib/miasma/specs.rb', line 6

def miasma_spec_sleep(interval = 20)
  if ENV["MIASMA_TEST_LIVE_REQUESTS"]
    sleep(20)
  else
    sleep(0.1)
  end
end