jsontest 1.0.0

data/lib/jsontest/matchers.rb

@@ -0,0 +1,33 @@
+require "jsontest/matchers/be_json_eql"
+require "jsontest/matchers/include_json"
+require "jsontest/matchers/have_json_path"
+require "jsontest/matchers/have_json_type"
+require "jsontest/matchers/have_json_size"
+
+module JsonTest
+  module Matchers
+    def be_json_eql(json = nil)
+      JsonTest::Matchers::BeJsonEql.new(json)
+    end
+
+    def include_json(json = nil)
+      JsonTest::Matchers::IncludeJson.new(json)
+    end
+
+    def have_json_path(path)
+      JsonTest::Matchers::HaveJsonPath.new(path)
+    end
+
+    def have_json_type(type)
+      JsonTest::Matchers::HaveJsonType.new(type)
+    end
+
+    def have_json_size(size)
+      JsonTest::Matchers::HaveJsonSize.new(size)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include JsonTest::Matchers
+end

data/lib/jsontest/matchers/be_json_eql.rb

@@ -0,0 +1,66 @@
+module JsonTest
+  module Matchers
+    class BeJsonEql
+      include JsonTest::Helpers
+      include JsonTest::Exclusion
+      include JsonTest::Messages
+
+      attr_reader :expected, :actual
+
+      def diffable?
+        true
+      end
+
+      def initialize(expected_json = nil)
+        @expected_json = expected_json
+        @path = nil
+      end
+
+      def matches?(actual_json)
+        raise "Expected equivalent JSON not provided" if @expected_json.nil?
+
+        @actual, @expected = scrub(actual_json, @path), scrub(@expected_json)
+        @actual == @expected
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def to_file(path)
+        @expected_json = load_json(path)
+        self
+      end
+
+      def excluding(*keys)
+        excluded_keys.merge(keys.map(&:to_s))
+        self
+      end
+
+      def including(*keys)
+        excluded_keys.subtract(keys.map(&:to_s))
+        self
+      end
+
+      def failure_message
+        message_with_path("Expected equivalent JSON")
+      end
+      alias :failure_message_for_should :failure_message
+
+      def failure_message_when_negated
+        message_with_path("Expected inequivalent JSON")
+      end
+      alias :failure_message_for_should_not :failure_message_when_negated
+
+      def description
+        message_with_path("equal JSON")
+      end
+
+      private
+        def scrub(json, path = nil)
+          generate_normalized_json(exclude_keys(parse_json(json, path))).chomp + "\n"
+        end
+    end
+  end
+end

data/lib/jsontest/matchers/have_json_path.rb

@@ -0,0 +1,32 @@
+module JsonTest
+  module Matchers
+    class HaveJsonPath
+      include JsonTest::Helpers
+
+      def initialize(path)
+        @path = path
+      end
+
+      def matches?(json)
+        parse_json(json, @path)
+        true
+      rescue JsonTest::MissingPath
+        false
+      end
+
+      def failure_message
+        %(Expected JSON path "#{@path}")
+      end
+      alias :failure_message_for_should :failure_message
+
+      def failure_message_when_negated
+        %(Expected no JSON path "#{@path}")
+      end
+      alias :failure_message_for_should_not :failure_message_when_negated
+
+      def description
+        %(have JSON path "#{@path}")
+      end
+    end
+  end
+end

data/lib/jsontest/matchers/have_json_size.rb

@@ -0,0 +1,39 @@
+module JsonTest
+  module Matchers
+    class HaveJsonSize
+      include JsonTest::Helpers
+      include JsonTest::Messages
+
+      def initialize(size)
+        @expected = size
+        @path = nil
+      end
+
+      def matches?(json)
+        ruby = parse_json(json, @path)
+        raise EnumerableExpected.new(ruby) unless Enumerable === ruby
+        @actual = ruby.size
+        @actual == @expected
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def failure_message
+        message_with_path("Expected JSON value size to be #{@expected}, got #{@actual}")
+      end
+      alias :failure_message_for_should :failure_message
+
+      def failure_message_when_negated
+        message_with_path("Expected JSON value size to not be #{@expected}, got #{@actual}")
+      end
+      alias :failure_message_for_should_not :failure_message_when_negated
+
+      def description
+        message_with_path(%(have JSON size "#{@expected}"))
+      end
+    end
+  end
+end

data/lib/jsontest/matchers/have_json_type.rb

@@ -0,0 +1,52 @@
+module JsonTest
+  module Matchers
+    class HaveJsonType
+      include JsonTest::Helpers
+      include JsonTest::Messages
+
+      def initialize(type)
+        @classes = type_to_classes(type)
+        @path = nil
+      end
+
+      def matches?(json)
+        @ruby = parse_json(json, @path)
+        @classes.any? { |c| c === @ruby }
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def failure_message
+        message_with_path("Expected JSON value type to be #{@classes.join(", ")}, got #{@ruby.class}")
+      end
+      alias :failure_message_for_should :failure_message
+
+      def failure_message_when_negated
+        message_with_path("Expected JSON value type to not be #{@classes.join(", ")}, got #{@ruby.class}")
+      end
+      alias :failure_message_for_should_not :failure_message_when_negated
+
+      def description
+        message_with_path(%(have JSON type "#{@classes.join(", ")}"))
+      end
+
+      private
+        def type_to_classes(type)
+          case type
+          when Class then [type]
+          when Array then type.map { |t| type_to_classes(t) }.flatten
+          else
+            case type.to_s.downcase
+            when "boolean"     then [TrueClass, FalseClass]
+            when "object"      then [Hash]
+            when "nil", "null" then [NilClass]
+            else [Module.const_get(type.to_s.capitalize)]
+            end
+          end
+        end
+    end
+  end
+end

data/lib/jsontest/matchers/include_json.rb

@@ -0,0 +1,63 @@
+module JsonTest
+  module Matchers
+    class IncludeJson
+      include JsonTest::Helpers
+      include JsonTest::Exclusion
+      include JsonTest::Messages
+
+      def initialize(expected_json = nil)
+        @expected_json = expected_json
+        @path = nil
+      end
+
+      def matches?(actual_json)
+        raise "Expected included JSON not provided" if @expected_json.nil?
+
+        @actual_json = actual_json
+
+        actual = parse_json(actual_json, @path)
+        expected = exclude_keys(parse_json(@expected_json))
+        case actual
+        when Hash then actual.values.map { |v| exclude_keys(v) }.include?(expected)
+        when Array then actual.map { |e| exclude_keys(e) }.include?(expected)
+        when String then actual.include?(expected)
+        else false
+        end
+      end
+
+      def at_path(path)
+        @path = path
+        self
+      end
+
+      def from_file(path)
+        @expected_json = load_json(path)
+        self
+      end
+
+      def excluding(*keys)
+        excluded_keys.merge(keys.map(&:to_s))
+        self
+      end
+
+      def including(*keys)
+        excluded_keys.subtract(keys.map(&:to_s))
+        self
+      end
+
+      def failure_message
+        message_with_path("Expected #{@actual_json} to include #{@expected_json}")
+      end
+      alias :failure_message_for_should :failure_message
+
+      def failure_message_when_negated
+        message_with_path("Expected #{@actual_json} to not include #{@expected_json}")
+      end
+      alias :failure_message_for_should_not :failure_message_when_negated
+
+      def description
+        message_with_path("include JSON")
+      end
+    end
+  end
+end

data/lib/jsontest/memory.rb

@@ -0,0 +1,19 @@
+module JsonTest
+  module Memory
+    def memory
+      @memory ||= {}
+    end
+
+    def memorize(key, value)
+      memory[key.to_sym] = value
+    end
+
+    def remember(json)
+      memory.empty? ? json : json % memory
+    end
+
+    def forget
+      memory.clear
+    end
+  end
+end

data/lib/jsontest/messages.rb

@@ -0,0 +1,8 @@
+module JsonTest
+  module Messages
+    def message_with_path(message)
+      message << %( at path "#{@path}") if @path
+      message
+    end
+  end
+end

data/spec/jsontest/configuration_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+describe JsonTest::Configuration do
+  it "excludes id and timestamps by default" do
+    JsonTest.excluded_keys.should eq ["id", "created_at", "updated_at"]
+  end
+
+  it "excludes custom keys" do
+    JsonTest.exclude_keys("token")
+    JsonTest.excluded_keys.should eq ["token"]
+  end
+
+  it "excludes custom keys via setter" do
+    JsonTest.excluded_keys = ["token"]
+    JsonTest.excluded_keys.should eq ["token"]
+  end
+
+  it "excludes custom keys via block" do
+    JsonTest.configure { |c| c.exclude_keys("token") }
+    JsonTest.excluded_keys.should eq ["token"]
+  end
+
+  it "excludes custom keys via block setter" do
+    JsonTest.configure { |c| c.excluded_keys = ["token"] }
+    JsonTest.excluded_keys.should eq ["token"]
+  end
+
+  it "excludes custom keys via instance-evaluated block" do
+    JsonTest.configure{ exclude_keys("token") }
+    JsonTest.excluded_keys.should eq ["token"]
+  end
+
+  it "ensures its excluded keys are strings" do
+    JsonTest.exclude_keys(:token)
+    JsonTest.excluded_keys.should eq ["token"]
+  end
+
+  it "ensures its excluded keys are unique" do
+    JsonTest.exclude_keys("token", :token)
+    JsonTest.excluded_keys.should eq ["token"]
+  end
+
+  it "resets its excluded keys" do
+    original = JsonTest.excluded_keys
+
+    JsonTest.exclude_keys("token")
+    JsonTest.excluded_keys.should_not eq original
+
+    JsonTest.reset
+    JsonTest.excluded_keys.should eq original
+  end
+
+  it "resets its directory" do
+    JsonTest.directory.should be_nil
+
+    JsonTest.directory = "/"
+    JsonTest.directory.should_not be_nil
+
+    JsonTest.reset
+    JsonTest.directory.should be_nil
+  end
+end

data/spec/jsontest/helpers_spec.rb

@@ -0,0 +1,111 @@
+require "spec_helper"
+
+describe JsonTest::Helpers do
+  include described_class
+
+  context "parse_json" do
+    it "parses JSON documents" do
+      parse_json(%({"json":["spec"]})).should eq({"json" => ["spec"]})
+    end
+
+    it "parses JSON values" do
+      parse_json(%("jsontest")).should eq "jsontest"
+    end
+
+    it "raises a parser error for invalid JSON" do
+      expect{ parse_json("jsontest") }.to raise_error(MultiJson::DecodeError)
+    end
+
+    it "parses at a path if given" do
+      json = %({"json":["spec"]})
+      parse_json(json, "json").should eq ["spec"]
+      parse_json(json, "json/0").should eq "spec"
+    end
+
+    it "raises an error for a missing path" do
+      json = %({"json":["spec"]})
+      %w(spec json/1).each do |path|
+        expect{ parse_json(json, path) }.to raise_error(JsonTest::MissingPath)
+      end
+    end
+
+    it "parses at a numeric string path" do
+      json = %({"1":"two"})
+      parse_json(json, "1").should eq "two"
+    end
+  end
+
+  context "normalize_json" do
+    it "normalizes a JSON document" do
+      normalized = <<-JSON
+{
+  "json": [
+    "spec"
+  ]
+}
+      JSON
+      normalize_json(%({"json":["spec"]})).should eq normalized.chomp
+    end
+
+    it "normalizes at a path" do
+      normalize_json(%({"json":["spec"]}), "json/0").should eq %("spec")
+    end
+
+    it "accepts a JSON value" do
+      normalize_json(%("jsontest")).should eq %("jsontest")
+    end
+
+    it "normalizes JSON values" do
+      normalize_json(%(1e+1)).should eq %(10.0)
+    end
+  end
+
+  context "generate_normalized_json" do
+    it "generates a normalized JSON document" do
+      normalized = <<-JSON
+{
+  "json": [
+    "spec"
+  ]
+}
+      JSON
+      generate_normalized_json({"json" => ["spec"]}).should eq normalized.chomp
+    end
+
+    it "generates a normalized JSON value" do
+      generate_normalized_json(nil).should eq %(null)
+    end
+  end
+
+  context "load_json_file" do
+    it "raises an error when no directory is set" do
+      expect{ load_json("one.json") }.to raise_error(JsonTest::MissingDirectory)
+    end
+
+    it "returns JSON when the file exists" do
+      JsonTest.directory = files_path
+      load_json("one.json").should eq %({"value":"from_file"})
+    end
+
+    it "ignores extra slashes" do
+      JsonTest.directory = "/#{files_path}/"
+      load_json("one.json").should eq %({"value":"from_file"})
+    end
+
+    it "raises an error when the file doesn't exist" do
+      JsonTest.directory = files_path
+      expect{ load_json("bogus.json") }.to raise_error(JsonTest::MissingFile)
+    end
+
+    it "raises an error when the directory doesn't exist" do
+      JsonTest.directory = "#{files_path}_bogus"
+      expect{ load_json("one.json") }.to raise_error(JsonTest::MissingFile)
+    end
+
+    it "finds nested files" do
+      JsonTest.directory = files_path
+      load_json("project/one.json").should eq %({"nested":"inside_folder"})
+      load_json("project/version/one.json").should eq %({"nested":"deeply"})
+    end
+  end
+end