hotdog 0.26.0 → 0.27.0

data/lib/hotdog/version.rb

@@ -1,3 +1,3 @@
 module Hotdog
-  VERSION = "0.26.0"
+  VERSION = "0.27.0"
 end

data/spec/core/commands_spec.rb

@@ -24,6 +24,9 @@ describe "commands" do
     cmd.options[:listing] = false
     cmd.options[:primary_tag] = nil
     allow(cmd).to receive(:update_db)
+    allow(cmd).to receive(:execute).with("SELECT id FROM hosts WHERE status = ? AND id IN (?, ?, ?);", [Hotdog::STATUS_RUNNING, 1, 2, 3]) {
+      [[1], [2], [3]]
+    }
     allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["host"])
     expect(cmd.__send__(:get_hosts, [1, 2, 3], []))
   end
@@ -32,6 +35,9 @@ describe "commands" do
     cmd.options[:listing] = false
     cmd.options[:primary_tag] = "foo"
     allow(cmd).to receive(:update_db)
+    allow(cmd).to receive(:execute).with("SELECT id FROM hosts WHERE status = ? AND id IN (?, ?, ?);", [Hotdog::STATUS_RUNNING, 1, 2, 3]) {
+      [[1], [2], [3]]
+    }
     allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["foo"])
     expect(cmd.__send__(:get_hosts, [1, 2, 3], []))
   end
@@ -40,6 +46,9 @@ describe "commands" do
     cmd.options[:listing] = false
     cmd.options[:primary_tag] = nil
     allow(cmd).to receive(:update_db)
+    allow(cmd).to receive(:execute).with("SELECT id FROM hosts WHERE status = ? AND id IN (?, ?, ?);", [Hotdog::STATUS_RUNNING, 1, 2, 3]) {
+      [[1], [2], [3]]
+    }
     allow(cmd).to receive(:get_hosts_fields).with([1, 2, 3], ["foo", "bar", "baz"])
     expect(cmd.__send__(:get_hosts, [1, 2, 3], ["foo", "bar", "baz"]))
   end
@@ -48,6 +57,9 @@ describe "commands" do
     cmd.options[:listing] = true
     cmd.options[:primary_tag] = nil
     allow(cmd).to receive(:update_db)
+    allow(cmd).to receive(:execute).with("SELECT id FROM hosts WHERE status = ? AND id IN (?, ?, ?);", [Hotdog::STATUS_RUNNING, 1, 2, 3]) {
+      [[1], [2], [3]]
+    }
     q1 = [
       "SELECT DISTINCT tags.name FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -64,6 +76,9 @@ describe "commands" do
     cmd.options[:listing] = true
     cmd.options[:primary_tag] = "bar"
     allow(cmd).to receive(:update_db)
+    allow(cmd).to receive(:execute).with("SELECT id FROM hosts WHERE status = ? AND id IN (?, ?, ?);", [Hotdog::STATUS_RUNNING, 1, 2, 3]) {
+      [[1], [2], [3]]
+    }
     q1 = [
       "SELECT DISTINCT tags.name FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -81,6 +96,9 @@ describe "commands" do
   end
 
   it "get host fields without host" do
+    allow(cmd).to receive(:execute).with("SELECT id FROM hosts WHERE status = ? AND id IN (?, ?, ?);", [Hotdog::STATUS_RUNNING, 1, 2, 3]) {
+      [[1], [2], [3]]
+    }
     q1 = [
       "SELECT LOWER(tags.name), GROUP_CONCAT(tags.value, ',') FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
@@ -100,6 +118,9 @@ describe "commands" do
   end
 
   it "get host fields with host" do
+    allow(cmd).to receive(:execute).with("SELECT id FROM hosts WHERE status = ? AND id IN (?, ?, ?);", [Hotdog::STATUS_RUNNING, 1, 2, 3]) {
+      [[1], [2], [3]]
+    }
     q1 = [
       "SELECT LOWER(tags.name), GROUP_CONCAT(tags.value, ',') FROM hosts_tags",
         "INNER JOIN tags ON hosts_tags.tag_id = tags.id",

data/spec/optimizer/binary_expression_spec.rb

@@ -5,43 +5,45 @@ require "hotdog/commands/search"
 require "parslet"
 
 describe "binary expression" do
-  it "everything AND x should return x" do
-    expr = Hotdog::Expression::BinaryExpressionNode.new("AND", Hotdog::Expression::EverythingNode.new(), Hotdog::Expression::NothingNode.new())
-    expect(expr.optimize.dump).to eq({
-      query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
-      values: [],
-    })
-  end
+  3.times do |o|
+    it "everything AND x should return x (#{o})" do
+      expr = Hotdog::Expression::BinaryExpressionNode.new("AND", Hotdog::Expression::EverythingNode.new(), Hotdog::Expression::NothingNode.new())
+      expect(optimize_n(o+1, expr).dump).to eq({
+        query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
+        values: [],
+      })
+    end
 
-  it "nothing AND x should return nothing" do
-    expr = Hotdog::Expression::BinaryExpressionNode.new("AND", Hotdog::Expression::NothingNode.new(), Hotdog::Expression::EverythingNode.new())
-    expect(expr.optimize.dump).to eq({
-      query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
-      values: [],
-    })
-  end
+    it "nothing AND x should return nothing (#{o})" do
+      expr = Hotdog::Expression::BinaryExpressionNode.new("AND", Hotdog::Expression::NothingNode.new(), Hotdog::Expression::EverythingNode.new())
+      expect(optimize_n(o+1, expr).dump).to eq({
+        query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
+        values: [],
+      })
+    end
 
-  it "everything OR x should return everything" do
-    expr = Hotdog::Expression::BinaryExpressionNode.new("OR", Hotdog::Expression::EverythingNode.new(), Hotdog::Expression::NothingNode.new())
-    expect(expr.optimize.dump).to eq({
-      query: "SELECT id AS host_id FROM hosts;",
-      values: [],
-    })
-  end
+    it "everything OR x should return everything (#{o})" do
+      expr = Hotdog::Expression::BinaryExpressionNode.new("OR", Hotdog::Expression::EverythingNode.new(), Hotdog::Expression::NothingNode.new())
+      expect(optimize_n(o+1, expr).dump).to eq({
+        query: "SELECT id AS host_id FROM hosts;",
+        values: [],
+      })
+    end
 
-  it "nothing OR x should return x" do
-    expr = Hotdog::Expression::BinaryExpressionNode.new("OR", Hotdog::Expression::NothingNode.new(), Hotdog::Expression::EverythingNode.new())
-    expect(expr.optimize.dump).to eq({
-      query: "SELECT id AS host_id FROM hosts;",
-      values: [],
-    })
-  end
+    it "nothing OR x should return x (#{o})" do
+      expr = Hotdog::Expression::BinaryExpressionNode.new("OR", Hotdog::Expression::NothingNode.new(), Hotdog::Expression::EverythingNode.new())
+      expect(optimize_n(o+1, expr).dump).to eq({
+        query: "SELECT id AS host_id FROM hosts;",
+        values: [],
+      })
+    end
 
-  it "everything XOR everything should return nothing" do
-    expr = Hotdog::Expression::BinaryExpressionNode.new("XOR", Hotdog::Expression::EverythingNode.new(), Hotdog::Expression::EverythingNode.new())
-    expect(expr.optimize.dump).to eq({
-      query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
-      values: [],
-    })
+    it "everything XOR everything should return nothing (#{o})" do
+      expr = Hotdog::Expression::BinaryExpressionNode.new("XOR", Hotdog::Expression::EverythingNode.new(), Hotdog::Expression::EverythingNode.new())
+      expect(optimize_n(o+1, expr).dump).to eq({
+        query: "SELECT NULL AS host_id WHERE host_id NOT NULL;",
+        values: [],
+      })
+    end
   end
 end

data/spec/optimizer/glob_expression_spec.rb

@@ -5,101 +5,103 @@ require "hotdog/commands/search"
 require "parslet"
 
 describe "tag glob expression" do
-  it "interprets tag glob with host" do
-    expr = Hotdog::Expression::GlobHostNode.new("foo*", ":")
-    expect(expr.optimize.dump).to eq({
-      tagname_glob: "host",
-      separator: ":",
-      tagvalue_glob: "foo*",
-      fallback: {
-        query: [
-          "SELECT hosts.id AS host_id FROM hosts",
-          "WHERE LOWER(hosts.name) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*"],
-      },
-    })
-  end
+  3.times do |o|
+    it "interprets tag glob with host (#{o})" do
+      expr = Hotdog::Expression::GlobHostNode.new("foo*", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname_glob: "host",
+        separator: ":",
+        tagvalue_glob: "foo*",
+        fallback: {
+          query: [
+            "SELECT hosts.id AS host_id FROM hosts",
+            "WHERE LOWER(hosts.name) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*"],
+        },
+      })
+    end
 
-  it "interprets tag glob with tagname and tagvalue" do
-    expr = Hotdog::Expression::GlobTagNode.new("foo*", "bar*", ":")
-    expect(expr.optimize.dump).to eq({
-      tagname_glob: "foo*",
-      separator: ":",
-      tagvalue_glob: "bar*",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(tags.name) GLOB LOWER(?) AND LOWER(tags.value) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*", "*bar*"],
-      },
-    })
-  end
+    it "interprets tag glob with tagname and tagvalue (#{o})" do
+      expr = Hotdog::Expression::GlobTagNode.new("foo*", "bar*", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname_glob: "foo*",
+        separator: ":",
+        tagvalue_glob: "bar*",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(tags.name) GLOB LOWER(?) AND LOWER(tags.value) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*", "*bar*"],
+        },
+      })
+    end
 
-  it "interprets tag glob with tagname with separator" do
-    expr = Hotdog::Expression::GlobTagnameNode.new("foo*", ":")
-    expect(expr.optimize.dump).to eq({
-      tagname_glob: "foo*",
-      separator: ":",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(tags.name) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*"],
-      },
-    })
-  end
+    it "interprets tag glob with tagname with separator (#{o})" do
+      expr = Hotdog::Expression::GlobTagnameNode.new("foo*", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname_glob: "foo*",
+        separator: ":",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(tags.name) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*"],
+        },
+      })
+    end
 
-  it "interprets tag glob with tagname without separator" do
-    expr = Hotdog::Expression::GlobHostOrTagNode.new("foo*", nil)
-    expect(expr.optimize.dump).to eq({
-      tagname_glob: "foo*",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*", "*foo*", "*foo*"],
-      },
-    })
-  end
+    it "interprets tag glob with tagname without separator (#{o})" do
+      expr = Hotdog::Expression::GlobHostOrTagNode.new("foo*", nil)
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname_glob: "foo*",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*", "*foo*", "*foo*"],
+        },
+      })
+    end
 
-  it "interprets tag glob with tagvalue with separator" do
-    expr = Hotdog::Expression::GlobTagvalueNode.new("foo*", ":")
-    expect(expr.optimize.dump).to eq({
-      separator: ":",
-      tagvalue_glob: "foo*",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*", "*foo*"],
-      },
-    })
-  end
+    it "interprets tag glob with tagvalue with separator (#{o})" do
+      expr = Hotdog::Expression::GlobTagvalueNode.new("foo*", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        separator: ":",
+        tagvalue_glob: "foo*",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*", "*foo*"],
+        },
+      })
+    end
 
-  it "interprets tag glob with tagvalue without separator" do
-    expr = Hotdog::Expression::GlobTagvalueNode.new("foo*", nil)
-    expect(expr.optimize.dump).to eq({
-      tagvalue_glob: "foo*",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*", "*foo*"],
-      }
-    })
+    it "interprets tag glob with tagvalue without separator (#{o})" do
+      expr = Hotdog::Expression::GlobTagvalueNode.new("foo*", nil)
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagvalue_glob: "foo*",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*", "*foo*"],
+        }
+      })
+    end
   end
 end

data/spec/optimizer/regexp_expression_spec.rb

@@ -5,51 +5,53 @@ require "hotdog/commands/search"
 require "parslet"
 
 describe "tag regexp expression" do
-  it "interprets tag regexp with host" do
-    expr = Hotdog::Expression::RegexpHostNode.new("foo", ":")
-    expect(expr.optimize.dump).to eq({
-      tagname_regexp: "host",
-       separator: ":",
-       tagvalue_regexp: "foo",
-    })
-  end
+  3.times do |o|
+    it "interprets tag regexp with host (#{o})" do
+      expr = Hotdog::Expression::RegexpHostNode.new("foo", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname_regexp: "host",
+         separator: ":",
+         tagvalue_regexp: "foo",
+      })
+    end
 
-  it "interprets tag regexp with tagname and tagvalue" do
-    expr = Hotdog::Expression::RegexpTagNode.new("foo", "bar", ":")
-    expect(expr.optimize.dump).to eq({
-      tagname_regexp: "foo",
-      separator: ":",
-      tagvalue_regexp: "bar",
-    })
-  end
+    it "interprets tag regexp with tagname and tagvalue (#{o})" do
+      expr = Hotdog::Expression::RegexpTagNode.new("foo", "bar", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname_regexp: "foo",
+        separator: ":",
+        tagvalue_regexp: "bar",
+      })
+    end
 
-  it "interprets tag regexp with tagname with separator" do
-    expr = Hotdog::Expression::RegexpTagnameNode.new("foo", ":")
-    expect(expr.optimize.dump).to eq({
-      tagname_regexp: "foo",
-      separator: ":",
-    })
-  end
+    it "interprets tag regexp with tagname with separator (#{o})" do
+      expr = Hotdog::Expression::RegexpTagnameNode.new("foo", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname_regexp: "foo",
+        separator: ":",
+      })
+    end
 
-  it "interprets tag regexp with tagname without separator" do
-    expr = Hotdog::Expression::RegexpHostOrTagNode.new("foo", nil)
-    expect(expr.optimize.dump).to eq({
-      tagname_regexp: "foo",
-    })
-  end
+    it "interprets tag regexp with tagname without separator (#{o})" do
+      expr = Hotdog::Expression::RegexpHostOrTagNode.new("foo", nil)
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname_regexp: "foo",
+      })
+    end
 
-  it "interprets tag regexp with tagvalue with separator" do
-    expr = Hotdog::Expression::RegexpTagvalueNode.new("foo", ":")
-    expect(expr.optimize.dump).to eq({
-      separator: ":",
-      tagvalue_regexp: "foo",
-    })
-  end
+    it "interprets tag regexp with tagvalue with separator (#{o})" do
+      expr = Hotdog::Expression::RegexpTagvalueNode.new("foo", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        separator: ":",
+        tagvalue_regexp: "foo",
+      })
+    end
 
-  it "interprets tag regexp with tagvalue without separator" do
-    expr = Hotdog::Expression::RegexpTagvalueNode.new("foo", nil)
-    expect(expr.optimize.dump).to eq({
-      tagvalue_regexp: "foo",
-    })
+    it "interprets tag regexp with tagvalue without separator (#{o})" do
+      expr = Hotdog::Expression::RegexpTagvalueNode.new("foo", nil)
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagvalue_regexp: "foo",
+      })
+    end
   end
 end

data/spec/optimizer/string_expression_spec.rb

@@ -5,101 +5,103 @@ require "hotdog/commands/search"
 require "parslet"
 
 describe "tag expression" do
-  it "interprets tag with host" do
-    expr = Hotdog::Expression::StringHostNode.new("foo", ":")
-    expect(expr.optimize.dump).to eq({
-      tagname: "host",
-      separator: ":",
-      tagvalue: "foo",
-      fallback: {
-        query: [
-          "SELECT hosts.id AS host_id FROM hosts",
-          "WHERE LOWER(hosts.name) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*"],
-      },
-    })
-  end
+  3.times do |o|
+    it "interprets tag with host (#{o})" do
+      expr = Hotdog::Expression::StringHostNode.new("foo", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname: "host",
+        separator: ":",
+        tagvalue: "foo",
+        fallback: {
+          query: [
+            "SELECT hosts.id AS host_id FROM hosts",
+            "WHERE LOWER(hosts.name) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*"],
+        },
+      })
+    end
 
-  it "interprets tag with tagname and tagvalue" do
-    expr = Hotdog::Expression::StringTagNode.new("foo", "bar", ":")
-    expect(expr.optimize.dump).to eq({
-      tagname: "foo",
-      separator: ":",
-      tagvalue: "bar",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(tags.name) GLOB LOWER(?) AND LOWER(tags.value) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*", "*bar*"],
-      },
-    })
-  end
+    it "interprets tag with tagname and tagvalue (#{o})" do
+      expr = Hotdog::Expression::StringTagNode.new("foo", "bar", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname: "foo",
+        separator: ":",
+        tagvalue: "bar",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(tags.name) GLOB LOWER(?) AND LOWER(tags.value) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*", "*bar*"],
+        },
+      })
+    end
 
-  it "interprets tag with tagname with separator" do
-    expr = Hotdog::Expression::StringTagnameNode.new("foo", ":")
-    expect(expr.optimize.dump).to eq({
-      tagname: "foo",
-      separator: ":",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(tags.name) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*"],
-      }
-    })
-  end
+    it "interprets tag with tagname with separator (#{o})" do
+      expr = Hotdog::Expression::StringTagnameNode.new("foo", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname: "foo",
+        separator: ":",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(tags.name) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*"],
+        }
+      })
+    end
 
-  it "interprets tag with tagname without separator" do
-    expr = Hotdog::Expression::StringHostOrTagNode.new("foo", nil)
-    expect(expr.optimize.dump).to eq({
-      tagname: "foo",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*", "*foo*", "*foo*"],
-      },
-    })
-  end
+    it "interprets tag with tagname without separator (#{o})" do
+      expr = Hotdog::Expression::StringHostOrTagNode.new("foo", nil)
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagname: "foo",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*", "*foo*", "*foo*"],
+        },
+      })
+    end
 
-  it "interprets tag with tagvalue with separator" do
-    expr = Hotdog::Expression::StringTagvalueNode.new("foo", ":")
-    expect(expr.optimize.dump).to eq({
-      tagvalue: "foo",
-      separator: ":",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*", "*foo*"],
-      },
-    })
-  end
+    it "interprets tag with tagvalue with separator (#{o})" do
+      expr = Hotdog::Expression::StringTagvalueNode.new("foo", ":")
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagvalue: "foo",
+        separator: ":",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*", "*foo*"],
+        },
+      })
+    end
 
-  it "interprets tag with tagvalue without separator" do
-    expr = Hotdog::Expression::StringTagvalueNode.new("foo", nil)
-    expect(expr.optimize.dump).to eq({
-      tagvalue: "foo",
-      fallback: {
-        query: [
-          "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
-          "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
-          "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
-          "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
-        ].join(" "),
-        values: ["*foo*", "*foo*"],
-      },
-    })
+    it "interprets tag with tagvalue without separator (#{o})" do
+      expr = Hotdog::Expression::StringTagvalueNode.new("foo", nil)
+      expect(optimize_n(o+1, expr).dump).to eq({
+        tagvalue: "foo",
+        fallback: {
+          query: [
+            "SELECT DISTINCT hosts_tags.host_id FROM hosts_tags",
+            "INNER JOIN hosts ON hosts_tags.host_id = hosts.id",
+            "INNER JOIN tags ON hosts_tags.tag_id = tags.id",
+            "WHERE LOWER(hosts.name) GLOB LOWER(?) OR LOWER(tags.value) GLOB LOWER(?);",
+          ].join(" "),
+          values: ["*foo*", "*foo*"],
+        },
+      })
+    end
   end
 end