mbrao 1.0.0

data/spec/mbrao/content_spec.rb

@@ -0,0 +1,280 @@
+# encoding: utf-8
+#
+# This file is part of the mbrao gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe Mbrao::Content do
+  let(:reference) { Mbrao::Content.new("UID") }
+
+  describe "#initialize" do
+    it "store the uid" do
+      reference = Mbrao::Content.new("SAMPLE")
+      expect(reference.uid).to eq("SAMPLE")
+    end
+  end
+
+  describe "#locales=" do
+    it "correctly assign a string, a symbol or an array" do
+      reference.locales = :it
+      expect(reference.locales).to eq(["it"])
+      reference.locales = "en"
+      expect(reference.locales).to eq(["en"])
+      reference.locales = ["en", [:it, :es]]
+      expect(reference.locales).to eq(["en", "it", "es"])
+    end
+  end
+
+  shared_examples_for("localized setter") do |attribute|
+    it "should assign a single string" do
+      reference.send("#{attribute}=", "ABC")
+      expect(reference.send(attribute)).to eq("ABC")
+      reference.send("#{attribute}=", 1)
+      expect(reference.send(attribute)).to eq("1")
+      reference.send("#{attribute}=", nil)
+      expect(reference.send(attribute)).to eq("")
+    end
+
+    it "should assign a string with locales and sanitized entries" do
+      reference.send("#{attribute}=", {en: nil, es: "ABC", it: 1})
+      value = reference.send(attribute)
+      expect(value).to be_a(::HashWithIndifferentAccess)
+      expect(value["en"]).to eq("")
+      expect(value[:es]).to eq("ABC")
+      expect(value["it"]).to eq("1")
+    end
+  end
+
+  shared_examples_for("localized getter") do |attribute, v1, v2|
+    it "should raise an exception if not available for that locale" do
+      reference.locales = [:en, :it, :es]
+      reference.send("#{attribute}=", v1)
+      expect { reference.send("get_#{attribute}", [:de, :it]) }.not_to raise_error(Mbrao::Exceptions::UnavailableLocalization)
+      expect { reference.send("get_#{attribute}", [:de]) }.to raise_error(Mbrao::Exceptions::UnavailableLocalization)
+    end
+
+    it "should return the attribute itself if not localized" do
+      reference.locales = [:en, :it, :es]
+      reference.send("#{attribute}=", v1)
+      expect(reference.send("get_#{attribute}", [:de, :it])).to eq(v1)
+    end
+
+    it "should return the default locale if no locales are specified" do
+      Mbrao::Parser.locale = :it
+      reference.send("#{attribute}=", {en: v1, it: v2})
+      expect(reference.send("get_#{attribute}")).to eq(v2)
+    end
+
+    it "should return only the subset of valid and request locales" do
+      Mbrao::Parser.locale = :it
+      reference.send("#{attribute}=", {en: v1, it: v2, de: v1, es: v2})
+
+      value = reference.send("get_#{attribute}", [:de, :es])
+      expect(value).to be_a(::HashWithIndifferentAccess)
+      expect(value.keys).to eq(["de", "es"])
+
+      value = reference.send("get_#{attribute}", [:it, :de, :pt, :fr])
+      expect(value.keys.sort).to eq(["de", "it"])
+
+      reference.locales = [:en, :it, :es]
+      value = reference.send("get_#{attribute}", "*")
+      expect(value.keys.sort).to eq(["de", "en", "es", "it"])
+
+      reference.send("#{attribute}=", {en: v1, "it,es" => v2, " de,    fr " => v1})
+      value = reference.send("get_#{attribute}", [:it, :fr])
+      expect(value.keys.sort).to eq(["fr", "it"])
+    end
+  end
+
+  shared_examples_for("date setter") do |attribute|
+    it "should correctly parse a datetime classes" do
+      reference.send("#{attribute}=", Date.civil(2012, 8, 8))
+      value = reference.send(attribute)
+      expect(value).to be_a(DateTime)
+      expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T000000+0000")
+
+      reference.send("#{attribute}=", DateTime.civil(2012, 8, 8, 11, 30, 45))
+      value = reference.send(attribute)
+      expect(value).to be_a(DateTime)
+      expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T113045+0000")
+
+      Time.zone = 'Europe/Rome'
+      date = Time.at(1344421800)
+      reference.send("#{attribute}=", date)
+      value = reference.send(attribute)
+      expect(value).to be_a(DateTime)
+      expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T103000+0000")
+    end
+
+    it "should correctly parse a timestamp" do
+      reference.send("#{attribute}=", 1344421800)
+      value = reference.send(attribute)
+      expect(value).to be_a(DateTime)
+      expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T103000+0000")
+    end
+
+    it "should try to parse everything else as a ISO8601 format" do
+      reference.send("#{attribute}=", "20120808T083000-0200")
+      value = reference.send(attribute)
+      expect(value).to be_a(DateTime)
+      expect(value.strftime("%Y%m%dT%H%M%S%z")).to eq("20120808T103000+0000")
+
+      expect { reference.send("#{attribute}=", "ABC") }.to raise_error(Mbrao::Exceptions::InvalidDate)
+      expect { reference.send("#{attribute}=", []) }.to raise_error(Mbrao::Exceptions::InvalidDate)
+    end
+  end
+
+  describe "#title=" do
+    it_should_behave_like "localized setter", :title
+  end
+
+  describe "#body=" do
+    it "should set the content as string" do
+      reference.body = "A"
+      expect(reference.body).to eq("A")
+      reference.body = 1
+      expect(reference.body).to eq("1")
+      reference.body = nil
+      expect(reference.body).to eq("")
+    end
+  end
+
+  describe "#tags=" do
+    it "should assign a single value" do
+      reference.tags = "ABC"
+      expect(reference.tags).to eq(["ABC"])
+      reference.tags = ["ABC", [1, nil]]
+      expect(reference.tags).to eq(["ABC", "1"])
+    end
+
+    it "should assign values with locales and sanitized entries" do
+      reference.tags = {en: nil, es: "ABC", it: [1, [2, 3]]}
+      value = reference.tags
+      expect(value).to be_a(::HashWithIndifferentAccess)
+      expect(value["en"]).to eq([])
+      expect(value[:es]).to eq(["ABC"])
+      expect(value["it"]).to eq(["1", "2", "3"])
+    end
+  end
+
+  describe "#more=" do
+    it_should_behave_like "localized setter", :more
+  end
+
+  describe "#author=" do
+    it "should assign an existing author" do
+      author = ::Mbrao::Author.new("NAME")
+      reference.author = author
+      expect(reference.author).to be(author)
+    end
+
+    it "should only assign a name" do
+      reference.author = "NAME"
+      expect(reference.author).to be_a(::Mbrao::Author)
+      expect(reference.author.name).to eq("NAME")
+    end
+
+    it "should assign by an hash" do
+      reference.author = {name: "NAME", email: "EMAIL@email.com", "website" => "http://WEBSITE.TLD", "image" => "http://IMAGE.TLD", metadata: {a: "b"}, uid: "UID"}
+      expect(reference.author).to be_a(::Mbrao::Author)
+      expect(reference.author.name).to eq("NAME")
+      expect(reference.author.email).to eq("EMAIL@email.com")
+      expect(reference.author.website).to eq("http://WEBSITE.TLD")
+      expect(reference.author.image).to eq("http://IMAGE.TLD")
+      expect(reference.author.metadata).to be_a(::HashWithIndifferentAccess)
+      expect(reference.author.metadata["a"]).to eq("b")
+      expect(reference.author.uid).to eq("UID")
+    end
+  end
+
+  describe "#created_at=" do
+    it_should_behave_like "date setter", :created_at
+  end
+
+  describe "#updated_at=" do
+    it_should_behave_like "date setter", :updated_at
+  end
+
+  describe "#metadata=" do
+    it "correctly set a non hash value" do
+      reference.metadata = "RAW"
+      expect(reference.metadata).to be_a(::HashWithIndifferentAccess)
+      expect(reference.metadata["raw"]).to eq("RAW")
+    end
+
+    it "correctly set a hash value" do
+      reference.metadata = {en: nil, es: "ABC", it: [1, [2, 3]]}
+      expect(reference.metadata).to be_a(::HashWithIndifferentAccess)
+      expect(reference.metadata["es"]).to eq("ABC")
+    end
+  end
+
+  describe "#enabled_for_locales?" do
+    it "correctly check availability for certain locales" do
+      reference.locales = [:en, :it]
+      expect(reference.enabled_for_locales?).to be_true
+      expect(reference.enabled_for_locales?(:en)).to be_true
+      expect(reference.enabled_for_locales?(:it, :es)).to be_true
+      expect(reference.enabled_for_locales?(:es, :de)).to be_false
+    end
+  end
+
+  describe "#get_title" do
+    it_should_behave_like "localized getter", :title, "ABC", "123"
+  end
+
+  describe "#get_body" do
+    it "should create a parsing engine and use it for filtering" do
+      reference.body = "BODY"
+      engine = ::Mbrao::ParsingEngines::Base.new
+      engine.should_receive(:filter_content).with(reference, ["it", "en"])
+      ::Mbrao::Parser.should_receive(:create_engine).with("ENGINE").and_return(engine)
+      reference.get_body(["it", "en"], "ENGINE")
+    end
+  end
+
+  describe "#get_tags" do
+    it_should_behave_like "localized getter", :tags, ["ABC", "123"], ["1", "2", "3", "4"]
+  end
+
+  describe "#get_more" do
+    it_should_behave_like "localized getter", :more, "ABC", "123"
+  end
+
+  describe ".create" do
+    it "should return a Content object" do
+      expect(::Mbrao::Content.create(nil, "BODY")).to be_a(::Mbrao::Content)
+    end
+
+    it "should assign the body" do
+      expect(::Mbrao::Content.create(nil, "BODY").body).to eq("BODY")
+    end
+
+    it "should assign metadata if present" do
+      created_at = DateTime.civil(1984, 7, 7, 11, 30, 0)
+      metadata = {"uid" => "UID", "title" => {it: "IT", en: "EN"}, "author" => "AUTHOR", "tags" => {it: "IT", en: "EN"}, "more" => "MORE", created_at: created_at, locales: ["it", ["en"]], other: ["OTHER"]}
+      content = ::Mbrao::Content.create(metadata, "BODY")
+
+      expect(content.uid).to eq("UID")
+      expect(content.title).to eq({"it" => "IT", "en" => "EN"})
+      expect(content.author).to be_a(::Mbrao::Author)
+      expect(content.author.name).to eq("AUTHOR")
+      expect(content.body).to eq("BODY")
+      expect(content.tags).to eq({"it" => ["IT"], "en" => ["EN"]})
+      expect(content.more).to eq("MORE")
+      expect(content.created_at).to eq(created_at)
+      expect(content.updated_at).to eq(created_at)
+      expect(content.locales).to eq(["it", "en"])
+      expect(content.metadata).to eq({"other" => ["OTHER"]})
+    end
+
+    it "should ignore invalid metadata" do
+      expect(::Mbrao::Content.create(nil, "BODY").metadata).to eq({})
+      expect(::Mbrao::Content.create(1, "BODY").metadata).to eq({})
+      expect(::Mbrao::Content.create([], "BODY").metadata).to eq({})
+      expect(::Mbrao::Content.create("A", "BODY").metadata).to eq({})
+    end
+  end
+end

data/spec/mbrao/integrations/rails_spec.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+#
+# This file is part of the mbrao gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe ActionView::Template::Handlers::MbraoTemplate do
+  class DummyTemplate
+    def initialize(content)
+      @content = content
+    end
+
+    def source
+      @content
+    end
+  end
+
+  class DummyController
+    def params
+      {locale: "LOCALE"}
+    end
+
+    def helper_method(method)
+    end
+  end
+
+  class DummyRenderer
+    def controller
+      @controller ||= DummyController.new
+    end
+  end
+
+  describe ".instance" do
+    it "should create a new instance" do
+      expect(ActionView::Template::Handlers::MbraoTemplate.instance).to be_a(ActionView::Template::Handlers::MbraoTemplate)
+    end
+
+    it "should always return the same instance" do
+      other = ActionView::Template::Handlers::MbraoTemplate.instance
+      ActionView::Template::Handlers::MbraoTemplate.should_not_receive(:new)
+      expect(ActionView::Template::Handlers::MbraoTemplate.instance).to eq(other)
+    end
+
+    it "should recreate an instance" do
+      other = ActionView::Template::Handlers::MbraoTemplate.instance
+      expect(ActionView::Template::Handlers::MbraoTemplate.instance(true)).not_to eq(other)
+    end
+  end
+
+
+  describe "#call" do
+    it "should return a Ruby snippet" do
+      expect(ActionView::Template::Handlers::MbraoTemplate.instance.call(DummyTemplate.new("CONTENT"))).to eq("ActionView::Template::Handlers::MbraoTemplate.instance.render(self, \"CONTENT\")")
+    end
+  end
+
+  describe "#render" do
+    it "should initialize a Content and assign it to the controller" do
+      controller = DummyController.new
+      renderer = DummyRenderer.new
+      renderer.stub(:controller).and_return(controller)
+
+      expect(controller.respond_to?(:mbrao_content)).to be_false
+      ::Mbrao::Parser.should_receive(:parse).and_call_original
+      controller.should_receive(:helper_method).with(:mbrao_content)
+      ActionView::Template::Handlers::MbraoTemplate.instance.render(renderer, "CONTENT")
+
+      expect(controller.respond_to?(:mbrao_content)).to be_true
+      expect(controller.mbrao_content.body).to eq("CONTENT")
+    end
+
+    it "should render contents, using specified engine and locale" do
+      controller = DummyController.new
+      renderer = DummyRenderer.new
+      renderer.stub(:controller).and_return(controller)
+
+      content = ::Mbrao::Content.create({engine: "ENGINE"}, "CONTENT")
+      ::Mbrao::Parser.stub(:parse).and_return(content)
+
+      ::Mbrao::Parser.should_receive(:render).with(content, {engine: "ENGINE", locale: "LOCALE"})
+      ActionView::Template::Handlers::MbraoTemplate.instance.render(DummyRenderer.new, "CONTENT")
+    end
+  end
+
+  describe "#supports_streaming?" do
+    it "should be true" do
+      expect(ActionView::Template::Handlers::MbraoTemplate.instance.supports_streaming?).to be_true
+    end
+  end
+end

data/spec/mbrao/parser_spec.rb

@@ -0,0 +1,269 @@
+# encoding: utf-8
+#
+# This file is part of the mbrao gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe Mbrao::Parser do
+  class BlankParser
+    def parse(content, options)
+
+    end
+  end
+
+  class ::Mbrao::ParsingEngines::ScopedParser
+    def parse(content, options)
+
+    end
+  end
+
+  shared_examples_for("attribute_with_default") do |attribute, default, sanitizer|
+    it "should return the default value" do
+      ::Mbrao::Parser.send("#{attribute}=", nil)
+      expect(::Mbrao::Parser.send(attribute)).to eq(default)
+    end
+
+    it "should return the set value sanitized" do
+      ::Mbrao::Parser.send("#{attribute}=", :en)
+      expect(::Mbrao::Parser.send(attribute)).to eq("en".send(sanitizer))
+    end
+  end
+
+  describe ".locale" do
+    it_should_behave_like("attribute_with_default", :locale, "en", :ensure_string)
+  end
+
+  describe ".parsing_engine" do
+    it_should_behave_like("attribute_with_default", :parsing_engine, :plain_text, :to_sym)
+  end
+
+  describe ".rendering_engine" do
+    it_should_behave_like("attribute_with_default", :rendering_engine, :html_pipeline, :to_sym)
+  end
+
+  describe ".parse" do
+    it "should forward to the instance" do
+      ::Mbrao::Parser.instance.should_receive(:parse).with("TEXT", {options: {}})
+      ::Mbrao::Parser.parse("TEXT", {options: {}})
+    end
+  end
+
+  describe ".render" do
+    it "should forward to the instance" do
+      ::Mbrao::Parser.instance.should_receive(:render).with("TEXT", {options: {}}, {content: {}})
+      ::Mbrao::Parser.render("TEXT", {options: {}}, {content: {}})
+    end
+  end
+
+  describe ".create_engine" do
+    it "should create an engine via .find_class" do
+      reference = ::Mbrao::ParsingEngines::ScopedParser.new
+      cls = ::Mbrao::ParsingEngines::ScopedParser
+      cls.should_receive(:new).exactly(2).and_return(reference)
+
+      ::Mbrao::Parser.should_receive(:find_class).with(:scoped_parser, "::Mbrao::ParsingEngines::%CLASS%").and_return(cls)
+      expect(::Mbrao::Parser.create_engine(:scoped_parser)).to eq(reference)
+      ::Mbrao::Parser.should_receive(:find_class).with(:scoped_parser, "::Mbrao::RenderingEngines::%CLASS%").and_return(cls)
+      expect(::Mbrao::Parser.create_engine(:scoped_parser, :rendering)).to eq(reference)
+    end
+
+    it "should raise an exception if the engine class is not found" do
+      expect { ::Mbrao::Parser.create_engine(:invalid) }.to raise_error(::Mbrao::Exceptions::UnknownEngine)
+    end
+  end
+
+  describe ".find_class" do
+    it "should return a valid class" do
+      expect(::Mbrao::Parser.find_class("String")).to eq(String)
+      expect(::Mbrao::Parser.find_class("ScopedParser", "::Mbrao::ParsingEngines::%CLASS%")).to eq(::Mbrao::ParsingEngines::ScopedParser)
+    end
+
+    it "should raise an exception if the class is not found" do
+      expect { ::Mbrao::Parser.find_class(:invalid) }.to raise_error(::Mbrao::Exceptions::Unimplemented)
+    end
+
+    it "should not expand engine scope if the class starts with ::" do
+      expect { ::Mbrao::Parser.find_class("::ScopedParser", "::Mbrao::ParsingEngines::%CLASS%") }.to raise_error(::Mbrao::Exceptions::Unimplemented)
+    end
+
+    it "should only use scope if requested to" do
+      expect { ::Mbrao::Parser.find_class("::Fixnum", "::Mbrao::ParsingEngines::%CLASS%", true) }.to raise_error(::Mbrao::Exceptions::Unimplemented)
+    end
+
+    it "should return anything but string or symbol as their class" do
+      expect(::Mbrao::Parser.find_class(nil)).to eq(NilClass)
+      expect(::Mbrao::Parser.find_class(1)).to eq(Fixnum)
+      expect(::Mbrao::Parser.find_class(["A"])).to eq(Array)
+      expect(::Mbrao::Parser.find_class({a: "b"})).to eq(Hash)
+    end
+  end
+
+  describe ".instance" do
+    it("should call .new") do
+      ::Mbrao::Parser.instance_variable_set(:@instance, nil)
+      ::Mbrao::Parser.should_receive(:new)
+      ::Mbrao::Parser.instance
+    end
+
+    it("should return the same instance") do
+      ::Mbrao::Parser.stub(:new) do Time.now end
+      instance = ::Mbrao::Parser.instance
+      expect(::Mbrao::Parser.instance).to be(instance)
+      ::Mbrao::Parser.instance_variable_set(:@instance, nil)
+    end
+
+    it("should return a new instance if requested to") do
+      ::Mbrao::Parser.stub(:new) do Time.now end
+      instance = ::Mbrao::Parser.instance
+      expect(::Mbrao::Parser.instance(true)).not_to be(instance)
+      ::Mbrao::Parser.instance_variable_set(:@instance, nil)
+    end
+  end
+
+  describe ".is_email?" do
+    it "should check for valid emails" do
+      expect(Mbrao::Parser.is_email?("valid@email.com")).to be_true
+      expect(Mbrao::Parser.is_email?("valid@localhost")).to be_false
+      expect(Mbrao::Parser.is_email?("this.is.9@email.com")).to be_true
+      expect(Mbrao::Parser.is_email?("INVALID")).to be_false
+      expect(Mbrao::Parser.is_email?(nil)).to be_false
+      expect(Mbrao::Parser.is_email?([])).to be_false
+      expect(Mbrao::Parser.is_email?("this.is.9@email.com.uk")).to be_true
+    end
+  end
+
+  describe ".is_url?" do
+    it "should check for valid URLs" do
+      expect(Mbrao::Parser.is_url?("http://google.it")).to be_true
+      expect(Mbrao::Parser.is_url?("ftp://ftp.google.com")).to be_true
+      expect(Mbrao::Parser.is_url?("http://google.it/?q=FOO+BAR")).to be_true
+      expect(Mbrao::Parser.is_url?("INVALID")).to be_false
+      expect(Mbrao::Parser.is_url?([])).to be_false
+      expect(Mbrao::Parser.is_url?(nil)).to be_false
+      expect(Mbrao::Parser.is_url?({})).to be_false
+    end
+  end
+
+  describe ".sanitized_hash" do
+    it "should inject a new hash from existing one" do
+      reference = {a: "b"}
+      reference.should_receive(:inject).with(an_instance_of(HashWithIndifferentAccess)).and_call_original
+      sanitized = Mbrao::Parser.sanitized_hash(reference)
+      expect(sanitized).to be_a(HashWithIndifferentAccess)
+      expect(sanitized["a"]).to eq("b")
+
+    end
+
+    it "should collect sanitized elements" do
+      reference = [{a: "b"}]
+      reference.should_receive(:collect).and_call_original
+      sanitized = Mbrao::Parser.sanitized_hash(reference)
+      expect(sanitized).to be_a(Array)
+      expect(sanitized[0]).to eq({"a" => "b"})
+
+    end
+
+    it "should iterate over nested elements recursively" do
+      reference = [{a: "b"}]
+      Mbrao::Parser.should_receive(:sanitized_hash).with(anything, :ensure_array).exactly(4).and_call_original
+      sanitized = Mbrao::Parser.sanitized_hash({c: reference}, :ensure_array)
+      expect(sanitized).to be_a(HashWithIndifferentAccess)
+      expect(sanitized["c"]).to eq([{"a" => ["b"]}])
+    end
+
+    it "should convert a non-enumerable object using a method" do
+      reference = {a: "b"}
+      expect(Mbrao::Parser.sanitized_hash(reference, :ensure_array).fetch("a")).to eq(["b"])
+    end
+
+    it "should convert a non-enumerable object using a block" do
+      reference = {a: ["b", "c"]}
+      expect((Mbrao::Parser.sanitized_hash(reference) {|v| v.upcase }.fetch("a"))).to eq(["B", "C"])
+    end
+
+    it "should not modify a non-enumerable object if requested to" do
+      reference = {a: nil}
+      expect((Mbrao::Parser.sanitized_hash(reference, false).fetch("a"))).to be_nil
+    end
+  end
+
+  describe ".sanitized_array" do
+    it "should return a sanitized array" do
+      expect(Mbrao::Parser.sanitized_array([:en, ["A", 1]])).to eq(["en", "A", "1"])
+      expect(Mbrao::Parser.sanitized_array(:en)).to eq(["en"])
+      expect(Mbrao::Parser.sanitized_array(:en)).to eq(["en"])
+      expect(Mbrao::Parser.sanitized_array([:en, nil])).to eq(["en", ""])
+    end
+
+    it "should not uniq if requested to" do
+      ref = [{a: "b"}]
+      ref.should_not_receive(:uniq)
+      expect(Mbrao::Parser.sanitized_array(ref, false)).to eq(["{:a=>\"b\"}"])
+    end
+
+    it "should compact if requested to" do
+      ref = [{a: "b"}, nil]
+      ref.should_not_receive(:compact)
+      expect(Mbrao::Parser.sanitized_array(ref, false, true)).to eq(["{:a=>\"b\"}"])
+    end
+
+    it "should use the requested method for sanitizing" do
+      ref = [{a: "b"}]
+      ref.should_not_receive(:ensure_string)
+      Hash.any_instance.should_receive(:to_json).and_call_original
+      expect(Mbrao::Parser.sanitized_array(ref, true, false, :to_json)).to eq(["{\"a\":\"b\"}"])
+    end
+
+    it "should use the block for sanitizing" do
+      ref = [{a: "b"}]
+      ref.should_not_receive(:ensure_string)
+      expect(Mbrao::Parser.sanitized_array(ref) {|e| e.keys.first }).to eq([:a])
+    end
+  end
+
+  describe "#parse" do
+    it "should sanitize options" do
+      reference = BlankParser.new
+      ::Mbrao::Parser.should_receive(:create_engine).exactly(3).and_return(reference)
+
+      reference.should_receive(:parse).with("CONTENT", {"metadata" => true, "content" => true, "engine" => :blank_parser})
+      reference.should_receive(:parse).with("CONTENT", {"metadata" => true, "content" => false, "engine" => :blank_parser})
+      reference.should_receive(:parse).with("CONTENT", {"metadata" => false, "content" => false, "engine" => :blank_parser})
+
+      ::Mbrao::Parser.new.parse("CONTENT", {engine: :blank_parser})
+      ::Mbrao::Parser.new.parse("CONTENT", {engine: :blank_parser, content: 2})
+      ::Mbrao::Parser.new.parse("CONTENT", {engine: :blank_parser, metadata: false, content: false})
+    end
+
+    it "should call .create_engine call its #parse method" do
+      reference = BlankParser.new
+      ::Mbrao::Parser.should_receive(:create_engine).and_return(reference)
+
+      reference.should_receive(:parse).with("CONTENT", {"metadata" => true, "content" => true, "engine" => :blank_parser, "other" => "OK"})
+      ::Mbrao::Parser.new.parse("CONTENT", {engine: :blank_parser, other: "OK"})
+    end
+  end
+
+  describe "#render" do
+    it "should sanitize options" do
+      reference = Object.new
+      ::Mbrao::Parser.should_receive(:create_engine).exactly(2).and_return(reference)
+
+      reference.should_receive(:render).with("CONTENT", {"engine" => :blank_rendered}, {content: "OK"})
+      reference.should_receive(:render).with("CONTENT", {"engine" => :html_pipeline}, {content: "OK"})
+
+      ::Mbrao::Parser.new.render("CONTENT", {engine: :blank_rendered}, {content: "OK"})
+      ::Mbrao::Parser.new.render("CONTENT", {engine: :html_pipeline}, {content: "OK"})
+    end
+
+    it "should call .create_engine call its #parse method" do
+      reference = Object.new
+      ::Mbrao::Parser.should_receive(:create_engine).with(:blank_rendered, :rendering).and_return(reference)
+
+      reference.should_receive(:render).with("CONTENT", {"engine" => :blank_rendered}, {content: "OK"})
+      ::Mbrao::Parser.new.render("CONTENT", {engine: :blank_rendered}, {content: "OK"})
+    end
+  end
+end

data/spec/mbrao/parsing_engines/base_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+#
+# This file is part of the mbrao gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+require "spec_helper"
+
+describe Mbrao::ParsingEngines::Base do
+  let(:reference) { Mbrao::ParsingEngines::Base.new }
+
+  shared_examples_for("unimplemented") do |method|
+    it "should raise an exception" do
+      expect { reference.send(method, "CONTENT", {}) }.to raise_error(Mbrao::Exceptions::Unimplemented)
+    end
+  end
+
+  describe "#separate_components" do
+    it_should_behave_like "unimplemented", :separate_components
+  end
+
+  describe "#parse_metadata" do
+    it_should_behave_like "unimplemented", :parse_metadata
+  end
+
+  describe "#filter_content" do
+    it_should_behave_like "unimplemented", :filter_content
+  end
+
+  describe "#parse" do
+    let(:reference) { ::Mbrao::ParsingEngines::Base.new }
+
+    it "should forward to ::Mbrao::Content.create" do
+      reference.should_receive(:separate_components).with("CONTENT", {a: "b"}).and_return([{a: "b"}, "BODY"])
+      reference.stub(:parse_metadata).and_return({a: "b"})
+      ::Mbrao::Content.should_receive(:create).with({a: "b"}, "BODY")
+      reference.parse("CONTENT", {a: "b"})
+    end
+
+    it "should return a Content object" do
+      reference.stub(:separate_components).with("CONTENT", {a: "b"}).and_return([])
+      reference.stub(:parse_metadata).and_return({})
+      expect(reference.parse("CONTENT", {a: "b"})).to be_a(::Mbrao::Content)
+    end
+
+    it "should separate_components" do
+      reference.should_receive(:separate_components).with("CONTENT", {a: "b"})
+      reference.stub(:parse_metadata).and_return({})
+      reference.parse("CONTENT", {a: "b"})
+    end
+  end
+end