kube_schema 1.12.0 → 2.0.0

data/lib/kube/schema/manifest.rb

@@ -4,30 +4,26 @@ require "yaml"
 
 module Kube
   module Schema
-    # A flat, ordered collection of Kubernetes resources.
-    #
-    # Manifest is Enumerable over Resource objects. It cannot be nested —
-    # appending one Manifest into another extracts and flattens its resources.
+    # A flat, ordered, Enumerable collection of Kubernetes resources.
     #
+    # @example
     #   manifest = Kube::Schema::Manifest.new
     #   manifest << deployment_resource
     #   manifest << another_manifest   # flattened automatically
     #   puts manifest.to_yaml          # multi-document YAML output
     #
-    # File I/O:
+    # @example File I/O
     #   manifest = Kube::Schema::Manifest.open("cluster.yaml")
     #   manifest << new_resource
     #   manifest.write
-    #
     class Manifest
       include Enumerable
 
       attr_reader :filename
 
       # Create a new Manifest, optionally seeded with resources.
-      #
-      # @param resources [Array<Resource, Manifest>] initial resources to include
-      # @param filename  [String, nil] optional filename for file-backed manifests
+      # @parameter resources [Array(Resource, Manifest)] initial resources to include.
+      # @parameter filename [String, nil] an optional filename for file-backed manifests.
       def initialize(*resources, filename: nil)
         @resources = []
         @filename  = filename
@@ -35,14 +31,9 @@ module Kube
         resources.each { |r| self << r }
       end
 
-      # Append a resource, manifest, or array of resources.
-      #
-      # - Resource objects are appended directly.
-      # - Manifest objects are flattened — their resources are extracted.
-      # - Arrays are iterated and each element is appended.
-      #
-      # @param item [Resource, Manifest, Array]
-      # @return [self]
+      # Append a resource, manifest, or array of either.
+      # @parameter item [Resource, Manifest, Array] what to append.
+      # @returns [self] appended; a Manifest is flattened, an Array iterated.
       def <<(item)
         case item
         when Manifest
@@ -60,94 +51,86 @@ module Kube
         self
       end
 
-      # @yield [Resource] each resource in insertion order
+      # @yields {|resource| ...} each resource in insertion order.
       def each(&block)
         @resources.each(&block)
       end
 
       # Number of resources in the manifest.
+      # @returns [Integer] the resource count.
       def size
         @resources.size
       end
       alias_method :length, :size
 
-      # Returns the manifest as multi-document YAML, separated by "---".
-      # This is the standard format for Kubernetes manifest files.
-      #
-      # @return [String]
+      # The manifest as "---"-separated multi-document YAML.
+      # @returns [String] the standard Kubernetes manifest file format.
       def to_yaml
         @resources.map { |r| r.to_yaml }.join("")
       end
 
       # Returns an array of resource hashes.
-      #
-      # @return [Array<Hash>]
+      # @returns [Array(Hash)] a copy of the resources, in order.
       def to_a
         @resources.dup
       end
 
-      # Ruby pattern matching: `manifest => [Kube::Cluster["Deployment"], *]`.
+      # Supports pattern matching, e.g. `manifest => [resource, *]`.
+      # @returns [Array(Hash)] the same array as #to_a.
       def deconstruct = to_a
 
-      # -------------------------------------------------------------------
-      # File I/O
-      # -------------------------------------------------------------------
+      # File I/O.
 
-      # Parse a YAML string containing one or more Kubernetes resource
-      # documents and return a Manifest populated with typed Resource objects.
-      #
-      # Each document's "kind" is resolved via Kube::Schema.parse to
-      # produce the correct Resource subclass (e.g. Deployment, Service).
-      # Documents without a recognized "kind" fall back to a bare Resource.
+      # Parse multi-document YAML into a Manifest of typed Resources.
       #
+      # @example
       #   yaml = `helm template my-release bitnami/nginx`
       #   manifest = Kube::Schema::Manifest.parse(yaml)
       #   manifest.first.class  #=> Kube::Schema::Resource (Deployment subclass)
       #
-      # @param yaml_string [String] multi-document YAML
-      # @return [Manifest]
+      # @parameter yaml_string [String] multi-document YAML.
+      # @returns [Manifest] the parsed resources.
       def self.parse(yaml_string)
-        docs = if YAML.respond_to?(:safe_load_stream)
-                 YAML.safe_load_stream(yaml_string, permitted_classes: [Symbol])
-               else
-                 YAML.load_stream(yaml_string)
-               end
+        if YAML.respond_to?(:safe_load_stream)
+          docs = YAML.safe_load_stream(yaml_string, permitted_classes: [Symbol])
+        else
+          docs = YAML.load_stream(yaml_string)
+        end
 
         resources = docs.compact.map { |doc| parse_doc(doc) }
         new(*resources)
       end
 
-      # Read a YAML file containing one or more Kubernetes resource documents
-      # and return a Manifest populated with typed Resource objects.
+      # Read a YAML file into a Manifest of typed Resources.
       #
+      # @example
       #   manifest = Kube::Schema::Manifest.open("deploy.yaml")
       #   manifest.count  #=> 3
       #   manifest.filename #=> "deploy.yaml"
       #
-      # @param path [String] path to a YAML file
-      # @return [Manifest]
+      # @parameter path [String] path to a YAML file.
+      # @returns [Manifest] the parsed resources, with filename set.
       def self.open(path)
         contents = File.read(path)
-        docs = if YAML.respond_to?(:safe_load_stream)
-                 YAML.safe_load_stream(contents, permitted_classes: [Symbol])
-               else
-                 # Ruby < 3.1 fallback
-                 YAML.load_stream(contents)
-               end
+        if YAML.respond_to?(:safe_load_stream)
+          docs = YAML.safe_load_stream(contents, permitted_classes: [Symbol])
+        else
+          docs = YAML.load_stream(contents)
+        end
 
         resources = docs.compact.map { |doc| parse_doc(doc) }
         new(*resources, filename: path)
       end
 
       # Write the manifest to a file as multi-document YAML.
-      #
-      # @param path [String, nil] destination path; defaults to the filename
-      #   the manifest was opened from.
-      # @return [String] the path written to
-      # @raise [ArgumentError] if no path is given and no filename is set
+      # @parameter path [String, nil] destination path, defaulting to #filename.
+      # @returns [String] the path written to.
+      # @raises [ArgumentError] if no path is given and no filename is set.
       def write(path = nil)
         path ||= @filename
-        raise ArgumentError, "No filename set. Pass a path to #write or use Manifest.open." if path.nil?
+        if path.nil?
+          raise ArgumentError, "No filename set. Pass a path to #write or use Manifest.open."
+        end
 
         File.write(path, to_yaml)
         @filename = path
@@ -155,10 +138,9 @@ module Kube
       end
 
       # Parse a single YAML document hash into a typed Resource.
-      #
-      # @param doc [Hash] a parsed YAML document
-      # @return [Resource]
-      # @raise [RuntimeError] if the kind is not recognized
+      # @parameter doc [Hash] a parsed YAML document.
+      # @returns [Resource] the typed resource.
+      # @raises [RuntimeError] if the kind is not recognized.
       def self.parse_doc(doc)
         Kube::Schema.parse(doc)
       end
@@ -167,7 +149,8 @@ module Kube
       private
 
         # Deep-stringify keys for clean YAML output.
-        # (Hash#to_yaml with symbol keys produces `:key:` which is ugly.)
+        # @parameter obj [Object] a Hash, Array, or scalar to stringify.
+        # @returns [Object] the same structure with string keys.
         def deep_stringify(obj)
           case obj
           when Hash
@@ -184,340 +167,318 @@ module Kube
   end
 end
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "rspec/autorun"
-  require "kube/schema"
-  require "tmpdir"
-
-  RSpec.describe Kube::Schema::Manifest do
-    let(:resource_a) { Kube::Schema["Deployment"].new }
-    let(:resource_b) { Kube::Schema["Service"].new }
-    let(:resource_c) { Kube::Schema["Namespace"].new }
-
-    describe "#initialize" do
-      it "creates an empty manifest with no arguments" do
-        manifest = described_class.new
-        expect(manifest.count).to eq(0)
-      end
 
-      it "accepts resources as arguments" do
-        manifest = described_class.new(resource_a, resource_b)
-        expect(manifest.count).to eq(2)
-      end
+__END__
 
-      it "accepts a filename keyword argument" do
-        manifest = described_class.new(filename: "/tmp/test.yaml")
-        expect(manifest.filename).to eq("/tmp/test.yaml")
-      end
-
-      it "flattens manifests passed as arguments" do
-        inner = described_class.new(resource_a, resource_b)
-        outer = described_class.new(inner, resource_c)
-        expect(outer.count).to eq(3)
-      end
-    end
-
-    describe "#<<" do
-      subject(:manifest) { described_class.new }
-
-      it "appends a Resource" do
-        manifest << resource_a
-        expect(manifest.count).to eq(1)
-        expect(manifest.first).to eq(resource_a)
-      end
-
-      it "returns self for chaining" do
-        result = manifest << resource_a
-        expect(result).to be(manifest)
-      end
+require "kube/schema"
+require "tmpdir"
+require "fileutils"
 
-      it "flattens a Manifest (cannot be nested)" do
-        other = described_class.new(resource_a, resource_b)
-        manifest << other
-        expect(manifest.count).to eq(2)
-        expect(manifest.to_a).to contain_exactly(resource_a, resource_b)
-      end
+manifest_class = Kube::Schema::Manifest
+resource_a = Kube::Schema["Deployment"].new
+resource_b = Kube::Schema["Service"].new
+resource_c = Kube::Schema["Namespace"].new
 
-      it "flattens an Array of Resources" do
-        manifest << [resource_a, resource_b]
-        expect(manifest.count).to eq(2)
-      end
+describe "Kube::Schema::Manifest" do
+  describe "#initialize" do
+    it "creates an empty manifest with no arguments" do
+      manifest_class.new.count.should == 0
+    end
 
-      it "raises ArgumentError for a Hash" do
-        expect { manifest << { "kind" => "Pod" } }.to raise_error(ArgumentError, /Expected a Kube::Schema::Resource/)
-      end
+    it "accepts resources as arguments" do
+      manifest_class.new(resource_a, resource_b).count.should == 2
+    end
 
-      it "raises ArgumentError for a String" do
-        expect { manifest << "not a resource" }.to raise_error(ArgumentError)
-      end
+    it "accepts a filename keyword argument" do
+      manifest_class.new(filename: "/tmp/test.yaml").filename.should == "/tmp/test.yaml"
+    end
 
-      it "supports chaining multiple appends" do
-        manifest << resource_a << resource_b << resource_c
-        expect(manifest.count).to eq(3)
-      end
+    it "flattens manifests passed as arguments" do
+      inner = manifest_class.new(resource_a, resource_b)
+      manifest_class.new(inner, resource_c).count.should == 3
     end
+  end
 
-    describe "Enumerable" do
-      subject(:manifest) { described_class.new(resource_a, resource_b, resource_c) }
+  describe "#<<" do
+    it "appends a Resource" do
+      manifest = manifest_class.new
+      manifest << resource_a
+      manifest.count.should == 1
+      manifest.first.should == resource_a
+    end
 
-      it "includes Enumerable" do
-        expect(described_class).to include(Enumerable)
-      end
+    it "returns self for chaining" do
+      manifest = manifest_class.new
+      (manifest << resource_a).should.be.identical_to manifest
+    end
 
-      it "yields resources in insertion order via #each" do
-        resources = []
-        manifest.each { |r| resources << r }
-        expect(resources).to eq([resource_a, resource_b, resource_c])
-      end
+    it "flattens a Manifest (cannot be nested)" do
+      manifest = manifest_class.new
+      manifest << manifest_class.new(resource_a, resource_b)
+      manifest.count.should == 2
+      manifest.to_a.should == [resource_a, resource_b]
+    end
 
-      it "supports #map" do
-        kinds = manifest.map { |r| r.to_h[:kind] }
-        expect(kinds).to eq(["Deployment", "Service", "Namespace"])
-      end
+    it "flattens an Array of Resources" do
+      manifest = manifest_class.new
+      manifest << [resource_a, resource_b]
+      manifest.count.should == 2
+    end
 
-      it "supports #select" do
-        services = manifest.select { |r| r.to_h[:kind] == "Service" }
-        expect(services.length).to eq(1)
-      end
+    it "raises ArgumentError for a Hash" do
+      manifest = manifest_class.new
+      error = lambda { manifest << { "kind" => "Pod" } }.should.raise(ArgumentError)
+      error.message.should.match(/Expected a Kube::Schema::Resource/)
+    end
 
-      it "supports #first and #last" do
-        expect(manifest.first).to eq(resource_a)
-        # Enumerable doesn't provide #last by default, but #to_a does
-        expect(manifest.to_a.last).to eq(resource_c)
-      end
+    it "raises ArgumentError for a String" do
+      manifest = manifest_class.new
+      lambda { manifest << "not a resource" }.should.raise(ArgumentError)
     end
 
-    describe "#size / #length" do
-      it "returns the number of resources" do
-        manifest = described_class.new(resource_a, resource_b)
-        expect(manifest.size).to eq(2)
-        expect(manifest.length).to eq(2)
-      end
+    it "supports chaining multiple appends" do
+      manifest = manifest_class.new
+      manifest << resource_a << resource_b << resource_c
+      manifest.count.should == 3
+    end
+  end
 
-      it "returns 0 for an empty manifest" do
-        manifest = described_class.new
-        expect(manifest.size).to eq(0)
-      end
+  describe "Enumerable" do
+    it "includes Enumerable" do
+      manifest_class.should.include Enumerable
     end
 
-    describe "pattern matching" do
-      it "destructures into an array of resources" do
-        manifest = described_class.new(resource_a, resource_b)
-        manifest => [Kube::Schema::Resource => first, *rest]
+    it "yields resources in insertion order via #each" do
+      resources = []
+      manifest_class.new(resource_a, resource_b, resource_c).each { |r| resources << r }
+      resources.should == [resource_a, resource_b, resource_c]
+    end
 
-        expect(first).to eq(resource_a)
-        expect(rest).to eq([resource_b])
-      end
+    it "supports #map" do
+      manifest = manifest_class.new(resource_a, resource_b, resource_c)
+      manifest.map { |r| r.to_h[:kind] }.should == ["Deployment", "Service", "Namespace"]
+    end
 
-      it "enforces arity" do
-        manifest = described_class.new(resource_a, resource_b)
-        expect { manifest => [Kube::Schema::Resource] }.to raise_error(NoMatchingPatternError)
-      end
+    it "supports #select" do
+      manifest = manifest_class.new(resource_a, resource_b, resource_c)
+      manifest.select { |r| r.to_h[:kind] == "Service" }.length.should == 1
     end
 
-    describe "#to_a" do
-      it "returns a copy of the internal resources array" do
-        manifest = described_class.new(resource_a, resource_b)
-        arr = manifest.to_a
-        expect(arr).to eq([resource_a, resource_b])
+    it "supports #first and #last" do
+      manifest = manifest_class.new(resource_a, resource_b, resource_c)
+      manifest.first.should == resource_a
+      # Enumerable doesn't provide #last by default, but #to_a does
+      manifest.to_a.last.should == resource_c
+    end
+  end
 
-        # Verify it's a copy, not the internal array
-        arr << resource_c
-        expect(manifest.count).to eq(2)
-      end
+  describe "#size / #length" do
+    it "returns the number of resources" do
+      manifest = manifest_class.new(resource_a, resource_b)
+      manifest.size.should == 2
+      manifest.length.should == 2
     end
 
-    describe "#to_yaml" do
-      it "returns multi-document YAML" do
-        manifest = described_class.new(resource_a, resource_b)
-        yaml = manifest.to_yaml
+    it "returns 0 for an empty manifest" do
+      manifest_class.new.size.should == 0
+    end
+  end
 
-        expect(yaml).to include("---")
-        expect(yaml).to include("kind: Deployment")
-        expect(yaml).to include("kind: Service")
-      end
+  describe "pattern matching" do
+    it "destructures into an array of resources" do
+      manifest = manifest_class.new(resource_a, resource_b)
+      manifest => [Kube::Schema::Resource => head, *rest]
 
-      it "uses string keys (not symbol keys) in output" do
-        manifest = described_class.new(resource_a)
-        yaml = manifest.to_yaml
+      head.should == resource_a
+      rest.should == [resource_b]
+    end
 
-        # Should NOT contain Ruby symbol syntax like `:kind:`
-        expect(yaml).not_to match(/:\w+:/)
-        expect(yaml).to include("kind: Deployment")
-        expect(yaml).to include("apiVersion: apps/v1")
-      end
+    it "enforces arity" do
+      manifest = manifest_class.new(resource_a, resource_b)
+      lambda { manifest => [Kube::Schema::Resource] }.should.raise(NoMatchingPatternError)
+    end
+  end
 
-      it "returns empty string for an empty manifest" do
-        manifest = described_class.new
-        expect(manifest.to_yaml).to eq("")
-      end
+  describe "#to_a" do
+    it "returns a copy of the internal resources array" do
+      manifest = manifest_class.new(resource_a, resource_b)
+      arr = manifest.to_a
+      arr.should == [resource_a, resource_b]
 
-      it "produces parseable YAML that round-trips" do
-        manifest = described_class.new(resource_a, resource_b)
-        yaml_output = manifest.to_yaml
-        docs = if YAML.respond_to?(:safe_load_stream)
-                 YAML.safe_load_stream(yaml_output)
-               else
-                 YAML.load_stream(yaml_output)
-               end
-        expect(docs.length).to eq(2)
-        expect(docs[0]["kind"]).to eq("Deployment")
-        expect(docs[1]["kind"]).to eq("Service")
-      end
+      # Verify it's a copy, not the internal array
+      arr << resource_c
+      manifest.count.should == 2
     end
+  end
 
-    describe ".parse" do
-      it "parses a single-document YAML string" do
-        yaml = { "kind" => "Pod", "apiVersion" => "v1", "metadata" => { "name" => "test" } }.to_yaml
-        manifest = described_class.parse(yaml)
+  describe "#to_yaml" do
+    it "returns multi-document YAML" do
+      yaml = manifest_class.new(resource_a, resource_b).to_yaml
 
-        expect(manifest.count).to eq(1)
-        expect(manifest.first).to be_a(Kube::Schema::Resource)
-        expect(manifest.first.kind).to eq("Pod")
-      end
+      yaml.should.include "---"
+      yaml.should.include "kind: Deployment"
+      yaml.should.include "kind: Service"
+    end
 
-      it "parses a multi-document YAML string" do
-        yaml = [
-          { "kind" => "Deployment", "apiVersion" => "apps/v1" },
-          { "kind" => "Service", "apiVersion" => "v1" }
-        ].map(&:to_yaml).join("")
+    it "uses string keys (not symbol keys) in output" do
+      yaml = manifest_class.new(resource_a).to_yaml
 
-        manifest = described_class.parse(yaml)
-        expect(manifest.count).to eq(2)
-      end
+      # Should NOT contain Ruby symbol syntax like `:kind:`
+      yaml.should.not.match(/:\w+:/)
+      yaml.should.include "kind: Deployment"
+      yaml.should.include "apiVersion: apps/v1"
+    end
 
-      it "returns typed Resource subclasses" do
-        yaml = { "kind" => "Deployment", "apiVersion" => "apps/v1", "metadata" => { "name" => "web" } }.to_yaml
-        manifest = described_class.parse(yaml)
+    it "returns empty string for an empty manifest" do
+      manifest_class.new.to_yaml.should == ""
+    end
 
-        resource = manifest.first
-        expect(resource.class.defaults).to eq({ "apiVersion" => "apps/v1", "kind" => "Deployment" })
-        expect(resource.kind).to eq("Deployment")
-      end
+    it "produces parseable YAML that round-trips" do
+      yaml_output = manifest_class.new(resource_a, resource_b).to_yaml
+      docs = if YAML.respond_to?(:safe_load_stream)
+               YAML.safe_load_stream(yaml_output)
+             else
+               YAML.load_stream(yaml_output)
+             end
+      docs.length.should == 2
+      docs[0]["kind"].should == "Deployment"
+      docs[1]["kind"].should == "Service"
+    end
+  end
 
-      it "skips nil documents (empty YAML docs)" do
-        yaml = "---\nkind: Pod\napiVersion: v1\n---\n---\nkind: Service\napiVersion: v1\n"
-        manifest = described_class.parse(yaml)
-        expect(manifest.count).to eq(2)
-      end
+  describe ".parse" do
+    it "parses a single-document YAML string" do
+      yaml = { "kind" => "Pod", "apiVersion" => "v1", "metadata" => { "name" => "test" } }.to_yaml
+      manifest = manifest_class.parse(yaml)
 
-      it "raises for unknown kinds" do
-        yaml = { "kind" => "UnknownCRD", "apiVersion" => "custom.io/v1" }.to_yaml
-        expect { described_class.parse(yaml) }.to raise_error(RuntimeError)
-      end
+      manifest.count.should == 1
+      manifest.first.should.be.kind_of Kube::Schema::Resource
+      manifest.first.kind.should == "Pod"
+    end
 
-      it "does not set a filename" do
-        yaml = { "kind" => "Pod", "apiVersion" => "v1" }.to_yaml
-        manifest = described_class.parse(yaml)
-        expect(manifest.filename).to be_nil
-      end
+    it "parses a multi-document YAML string" do
+      yaml = [
+        { "kind" => "Deployment", "apiVersion" => "apps/v1" },
+        { "kind" => "Service", "apiVersion" => "v1" }
+      ].map(&:to_yaml).join("")
 
-      it "returns an empty manifest for empty YAML" do
-        manifest = described_class.parse("---\n")
-        expect(manifest.count).to eq(0)
-      end
+      manifest_class.parse(yaml).count.should == 2
     end
 
-    describe ".open" do
-      let(:tmpdir) { Dir.mktmpdir("manifest_test") }
-      let(:yaml_path) { File.join(tmpdir, "resources.yaml") }
+    it "returns typed Resource subclasses" do
+      yaml = { "kind" => "Deployment", "apiVersion" => "apps/v1", "metadata" => { "name" => "web" } }.to_yaml
+      resource = manifest_class.parse(yaml).first
 
-      after { FileUtils.rm_rf(tmpdir) }
+      resource.class.defaults.should == { "apiVersion" => "apps/v1", "kind" => "Deployment" }
+      resource.kind.should == "Deployment"
+    end
 
-      it "reads a single-document YAML file" do
-        File.write(yaml_path, { "kind" => "Pod", "apiVersion" => "v1" }.to_yaml)
+    it "skips nil documents (empty YAML docs)" do
+      yaml = "---\nkind: Pod\napiVersion: v1\n---\n---\nkind: Service\napiVersion: v1\n"
+      manifest_class.parse(yaml).count.should == 2
+    end
 
-        manifest = described_class.open(yaml_path)
-        expect(manifest.count).to eq(1)
-        expect(manifest.first).to be_a(Kube::Schema::Resource)
-      end
+    it "raises for unknown kinds" do
+      yaml = { "kind" => "UnknownCRD", "apiVersion" => "custom.io/v1" }.to_yaml
+      lambda { manifest_class.parse(yaml) }.should.raise(RuntimeError)
+    end
 
-      it "reads a multi-document YAML file" do
-        content = [
-          { "kind" => "Deployment", "apiVersion" => "apps/v1" },
-          { "kind" => "Service", "apiVersion" => "v1" }
-        ].map(&:to_yaml).join("")
+    it "does not set a filename" do
+      yaml = { "kind" => "Pod", "apiVersion" => "v1" }.to_yaml
+      manifest_class.parse(yaml).filename.should.be.nil
+    end
 
-        File.write(yaml_path, content)
+    it "returns an empty manifest for empty YAML" do
+      manifest_class.parse("---\n").count.should == 0
+    end
+  end
 
-        manifest = described_class.open(yaml_path)
-        expect(manifest.count).to eq(2)
-      end
+  describe ".open" do
+    before { @tmpdir = Dir.mktmpdir("manifest_test") }
+    after  { FileUtils.rm_rf(@tmpdir) }
 
-      it "sets the filename" do
-        File.write(yaml_path, { "kind" => "Pod" }.to_yaml)
+    it "reads a single-document YAML file" do
+      path = File.join(@tmpdir, "resources.yaml")
+      File.write(path, { "kind" => "Pod", "apiVersion" => "v1" }.to_yaml)
 
-        manifest = described_class.open(yaml_path)
-        expect(manifest.filename).to eq(yaml_path)
-      end
+      manifest = manifest_class.open(path)
+      manifest.count.should == 1
+      manifest.first.should.be.kind_of Kube::Schema::Resource
+    end
 
-      it "skips nil documents (empty YAML docs)" do
-        File.write(yaml_path, "---\nkind: Pod\n---\n---\nkind: Service\n")
+    it "reads a multi-document YAML file" do
+      path = File.join(@tmpdir, "resources.yaml")
+      File.write(path, [
+        { "kind" => "Deployment", "apiVersion" => "apps/v1" },
+        { "kind" => "Service", "apiVersion" => "v1" }
+      ].map(&:to_yaml).join(""))
 
-        manifest = described_class.open(yaml_path)
-        expect(manifest.count).to eq(2)
-      end
+      manifest_class.open(path).count.should == 2
     end
 
-    describe "#write" do
-      let(:tmpdir) { Dir.mktmpdir("manifest_test") }
+    it "sets the filename" do
+      path = File.join(@tmpdir, "resources.yaml")
+      File.write(path, { "kind" => "Pod" }.to_yaml)
 
-      after { FileUtils.rm_rf(tmpdir) }
+      manifest_class.open(path).filename.should == path
+    end
 
-      it "writes to the given path" do
-        path = File.join(tmpdir, "output.yaml")
-        manifest = described_class.new(resource_a)
+    it "skips nil documents (empty YAML docs)" do
+      path = File.join(@tmpdir, "resources.yaml")
+      File.write(path, "---\nkind: Pod\n---\n---\nkind: Service\n")
 
-        manifest.write(path)
-        expect(File.exist?(path)).to be true
+      manifest_class.open(path).count.should == 2
+    end
+  end
 
-        content = File.read(path)
-        expect(content).to include("kind: Deployment")
-      end
+  describe "#write" do
+    before { @tmpdir = Dir.mktmpdir("manifest_test") }
+    after  { FileUtils.rm_rf(@tmpdir) }
 
-      it "writes to the stored filename when no path is given" do
-        path = File.join(tmpdir, "stored.yaml")
-        manifest = described_class.new(resource_a, filename: path)
+    it "writes to the given path" do
+      path = File.join(@tmpdir, "output.yaml")
+      manifest_class.new(resource_a).write(path)
 
-        manifest.write
-        expect(File.exist?(path)).to be true
-      end
+      File.exist?(path).should.be.true
+      File.read(path).should.include "kind: Deployment"
+    end
 
-      it "updates the filename after writing to a new path" do
-        path = File.join(tmpdir, "new.yaml")
-        manifest = described_class.new(resource_a)
+    it "writes to the stored filename when no path is given" do
+      path = File.join(@tmpdir, "stored.yaml")
+      manifest_class.new(resource_a, filename: path).write
 
-        manifest.write(path)
-        expect(manifest.filename).to eq(path)
-      end
+      File.exist?(path).should.be.true
+    end
 
-      it "returns the path written to" do
-        path = File.join(tmpdir, "result.yaml")
-        manifest = described_class.new(resource_a)
+    it "updates the filename after writing to a new path" do
+      path = File.join(@tmpdir, "new.yaml")
+      manifest = manifest_class.new(resource_a)
 
-        result = manifest.write(path)
-        expect(result).to eq(path)
-      end
+      manifest.write(path)
+      manifest.filename.should == path
+    end
 
-      it "raises ArgumentError when no path is available" do
-        manifest = described_class.new(resource_a)
-        expect { manifest.write }.to raise_error(ArgumentError, /No filename set/)
-      end
+    it "returns the path written to" do
+      path = File.join(@tmpdir, "result.yaml")
+      manifest_class.new(resource_a).write(path).should == path
+    end
 
-      it "round-trips through write and open" do
-        path = File.join(tmpdir, "roundtrip.yaml")
-        original = described_class.new(resource_a, resource_b)
+    it "raises ArgumentError when no path is available" do
+      manifest = manifest_class.new(resource_a)
+      error = lambda { manifest.write }.should.raise(ArgumentError)
+      error.message.should.match(/No filename set/)
+    end
 
-        original.write(path)
-        loaded = described_class.open(path)
+    it "round-trips through write and open" do
+      path = File.join(@tmpdir, "roundtrip.yaml")
+      original = manifest_class.new(resource_a, resource_b)
 
-        expect(loaded.count).to eq(original.count)
+      original.write(path)
+      manifest_class.open(path).count.should == original.count
 
-        content = File.read(path)
-        expect(content).to include("kind: Deployment")
-        expect(content).to include("kind: Service")
-      end
+      content = File.read(path)
+      content.should.include "kind: Deployment"
+      content.should.include "kind: Service"
     end
   end
 end