miasma 0.2.16 → 0.2.18

data/test/specs/models/orchestration_abstract.rb

@@ -0,0 +1,123 @@
+MIASMA_ORCHESTRATION_ABSTRACT = ->{
+
+  # Required `let`s:
+  # * orchestration: orchestration API
+  # * build_args: stack build arguments [Smash]
+  # * cassette_prefix: cassette file prefix [String]
+
+  describe Miasma::Models::Orchestration 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
+        VCR.use_cassette("#{cassette_prefix}_stacks_all") do
+          orchestration.stacks.all.must_be_kind_of Array
+        end
+      end
+
+    end
+
+    describe Miasma::Models::Orchestration::Stacks do
+
+      before do
+        @stack = orchestration.stacks.build(build_args)
+        VCR.use_cassette("#{cassette_prefix}_stacks_before_create") do |obj|
+          @stack.save
+          until(@stack.state == :create_complete)
+            sleep(obj.recording? ? 60 : 0.01)
+            @stack.reload
+          end
+          @stack.template
+          orchestration.stacks.reload
+        end
+      end
+
+      after do
+        VCR.use_cassette("#{cassette_prefix}_stacks_after_destroy") do
+          @stack.destroy
+        end
+      end
+
+      let(:stack){ @stack }
+
+      describe 'collection' do
+
+        it 'should include stack' do
+          VCR.use_cassette("#{cassette_prefix}_stacks_direct_fetch") do
+            orchestration.stacks.all.detect{|s| s.id == stack.id}.wont_be_nil
+            orchestration.stacks.get(stack.id).wont_be_nil
+          end
+        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
+        VCR.use_cassette("#{cassette_prefix}_stack_create") do |obj|
+          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)
+            sleep(obj.recording? ? 60 : 0.01)
+            stack.reload
+          end
+          stack.state.must_equal :create_complete
+          stack.destroy
+          [:delete_in_progress, :delete_complete].must_include stack.state
+          until(stack.state == :delete_complete)
+            sleep(obj.recording? ? 60 : 0.01)
+            stack.reload
+          end
+          stack.state.must_equal :delete_complete
+        end
+      end
+
+    end
+
+  end
+}

data/test/specs/models/storage_abstract.rb

@@ -0,0 +1,120 @@
+require 'open-uri'
+
+MIASMA_STORAGE_ABSTRACT = ->{
+
+  # Required `let`s:
+  # * storage: storage API
+  # * cassette_prefix: cassette file prefix [String]
+
+  describe Miasma::Models::Storage 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
+        VCR.use_cassette("#{cassette_prefix}_buckets_all") do
+          storage.buckets.all.must_be_kind_of Array
+        end
+      end
+
+    end
+
+    describe Miasma::Models::Storage::Bucket do
+
+      it 'should act like a bucket' do
+        bucket = storage.buckets.build(:name => 'miasma-test-bucket-010')
+        VCR.use_cassette("#{cassette_prefix}_storage_bucket") do |obj|
+          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 * 2)
+          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
+
+  end
+}

data/test/specs/utils/animal_strings_spec.rb

@@ -0,0 +1,15 @@
+describe Miasma::Utils::AnimalStrings do
+
+  it 'should camel case strings' do
+    Miasma::Utils.camel('fubar_foobar_fuobar').must_equal 'FubarFoobarFuobar'
+  end
+
+  it 'should camel case symbols' do
+    Miasma::Utils.camel(:fubar_foobar_fuobar).must_equal 'FubarFoobarFuobar'
+  end
+
+  it 'should snake case strings' do
+    Miasma::Utils.snake('FubarFoobarFuobar').must_equal 'fubar_foobar_fuobar'
+  end
+
+end

data/test/specs/utils/memoization_spec.rb

@@ -0,0 +1,83 @@
+describe Miasma::Utils::Memoization do
+
+  before do
+    @memo = Object.new
+    @memo.extend Miasma::Utils::Memoization
+  end
+
+  after do
+    Thread.current[:miasma_memoization] = nil
+  end
+
+  let(:memo){ @memo }
+
+  it 'should #memoize the value returned by block' do
+    value = Kernel.rand
+    memo.memoize(:test) do
+      value
+    end.must_equal value
+    memo.memoize(:test){ Kernel.rand }.must_equal value
+  end
+
+  it 'should not return #memoize value from other instance' do
+    memo2 = Object.new
+    memo2.extend Miasma::Utils::Memoization
+    value = Kernel.rand
+    memo.memoize(:test) do
+      value
+    end.must_equal value
+    memo.memoize(:test){ Kernel.rand }.must_equal value
+    memo2.memoize(:test){ Kernel.rand }.wont_equal value
+  end
+
+  it 'should #unmemoize a memoized value' do
+    value = Kernel.rand
+    value2 = Kernel.rand
+    memo.memoize(:test) do
+      value
+    end.must_equal value
+    memo.unmemoize(:test)
+    memo.memoize(:test) do
+      value2
+    end.must_equal value2
+  end
+
+  it 'should allow direct #memoize not restricted to object' do
+    memo2 = Object.new
+    memo2.extend Miasma::Utils::Memoization
+    value = Kernel.rand
+    memo.memoize(:test, true) do
+      value
+    end.must_equal value
+    memo.memoize(:test, true){ Kernel.rand }.must_equal value
+    memo2.memoize(:test, true){ Kernal.rand }.must_equal value
+  end
+
+  it 'should clear all non-direct memoizations with #clear_memoizations!' do
+    memo2 = Object.new
+    memo2.extend Miasma::Utils::Memoization
+    value = Kernel.rand
+    memo.memoize(:test, true) do
+      value
+    end.must_equal value
+    memo.memoize(:test){ value }.must_equal value
+    memo2.memoize(:test){ value }.must_equal value
+
+    memo.memoize(:test, true){ Kernel.rand }.must_equal value
+    memo2.memoize(:test, true){ Kernel.rand }.must_equal value
+    memo.memoize(:test){ Kernel.rand }.must_equal value
+    memo2.memoize(:test){ Kernel.rand }.must_equal value
+
+    memo.clear_memoizations!
+    memo.memoize(:test){ Kernel.rand }.wont_equal value
+    memo2.memoize(:test){ Kernel.rand }.must_equal value
+
+    memo2.clear_memoizations!
+    memo.memoize(:test){ Kernel.rand }.wont_equal value
+    memo2.memoize(:test){ Kernel.rand }.wont_equal value
+
+    memo.memoize(:test, true){ Kernel.rand }.must_equal value
+    memo2.memoize(:test, true){ Kernel.rand }.must_equal value
+  end
+
+end

data/test/specs/utils/smash_spec.rb

@@ -0,0 +1,107 @@
+describe Miasma::Utils::Smash do
+
+  it 'should provide top level constant' do
+    defined?(::Smash).wont_be_nil
+  end
+
+  it 'should provide #to_smash on Hash' do
+    Hash.instance_methods.must_include :to_smash
+  end
+
+  it 'should convert Hash to Smash' do
+    {:a => 1}.to_smash.must_equal Smash.new(:a => 1)
+  end
+
+  it 'should sort keys when converting' do
+    hash = {:z => 1, :d => 3, :m => 1}
+    smash = Smash.new(:d => 3, :m => 1, :z => 1)
+    hash.to_smash.must_equal smash
+  end
+
+  it 'should convert deep nested Hashes to Smashes' do
+    hash = {
+      :a => 1,
+      :b => [
+        {:c => 2},
+        {:d => 3}
+      ]
+    }
+    smash = Smash.new(
+      :a => 1,
+      :b => [
+        Smash.new(:c => 2),
+        Smash.new(:d => 3)
+      ]
+    )
+    hash.to_smash.must_equal smash
+  end
+
+  it 'should #get deeply nested value' do
+    smash = {
+      :a => {
+        :b => {
+          :c => {
+            :d => 1
+          }
+        }
+      }
+    }.to_smash
+    smash.get(:a, :b, :c, :d).must_equal 1
+  end
+
+  it 'should #get nil on missing deeply nested value' do
+    smash = {
+      :a => {
+        :b => {
+          :c => {
+            :d => 1
+          }
+        }
+      }
+    }.to_smash
+    smash.get(:a, :b, :c, :x).must_be_nil
+  end
+
+  it 'should #set deeply nested value' do
+    smash = Smash.new
+    smash.set(:a, :b, :c, 1)
+    smash.get(:a, :b, :c).must_equal 1
+  end
+
+  it 'should #fetch default value on missing' do
+    smash = {
+      :a => {
+        :b => {
+          :c => {
+            :d => 1
+          }
+        }
+      }
+    }.to_smash
+    smash.fetch(:a, :b, :c, :x, 1).must_equal 1
+  end
+
+  it 'should #fetch value when availble' do
+    smash = {
+      :a => {
+        :b => {
+          :c => {
+            :d => 1
+          }
+        }
+      }
+    }.to_smash
+    smash.fetch(:a, :b, :c, :d, 0).must_equal 1
+  end
+
+  it 'should generate a #checksum' do
+    Smash.new(:a => 1).checksum.must_be_kind_of String
+  end
+
+  it 'should generate equal #checksum' do
+    hash = {:z => 1, :d => 3}
+    smash = Smash.new(:d => 3, :z => 1)
+    hash.to_smash.checksum.must_equal smash.checksum
+  end
+
+end