openerp.testing.section('search.query', {
    dependencies: ['web.search']
}, function (test) {
    test('Adding a facet to the query creates a facet and a value', function (instance) {
        var query = new instance.web.search.SearchQuery();
        var field = {};
        query.add({
            category: 'Foo',
            field: field,
            values: [{label: 'Value', value: 3}]
        });

        var facet = query.at(0);
        equal(facet.get('category'), 'Foo');
        equal(facet.get('field'), field);
        deepEqual(facet.get('values'), [{label: 'Value', value: 3}]);
    });
    test('Adding two facets', function (instance) {
        var query = new instance.web.search.SearchQuery();
        query.add([
            { category: 'Foo', field: {}, values: [{label: 'Value', value: 3}] },
            { category: 'Bar', field: {}, values: [{label: 'Value 2', value: 4}] }
        ]);

        equal(query.length, 2);
        equal(query.at(0).values.length, 1);
        equal(query.at(1).values.length, 1);
    });
    test('If a facet already exists, add values to it', function (instance) {
        var query = new instance.web.search.SearchQuery();
        var field = {};
        query.add({category: 'A', field: field, values: [{label: 'V1', value: 0}]});
        query.add({category: 'A', field: field, values: [{label: 'V2', value: 1}]});

        equal(query.length, 1, "adding an existing facet should merge new values into old facet");
        var facet = query.at(0);
        deepEqual(facet.get('values'), [
            {label: 'V1', value: 0},
            {label: 'V2', value: 1}
        ]);
    });
    test('Facet being implicitly changed should trigger change, not add', function (instance) {
        var query = new instance.web.search.SearchQuery();
        var field = {}, added = false, changed = false;
        query.add({category: 'A', field: field, values: [{label: 'V1', value: 0}]});
        query.on('add', function () { added = true; })
             .on('change', function () { changed = true; });
        query.add({category: 'A', field: field, values: [{label: 'V2', value: 1}]});

        ok(!added, "query.add adding values to a facet should not trigger an add");
        ok(changed, "query.add adding values to a facet should not trigger a change");
    });
    test('Toggling a facet, value which does not exist should add it', function (instance) {
        var query = new instance.web.search.SearchQuery();
        var field = {};
        query.toggle({category: 'A', field: field, values: [{label: 'V1', value: 0}]});

        equal(query.length, 1, "Should have created a single facet");
        var facet = query.at(0);
        equal(facet.values.length, 1, "Facet should have a single value");
        deepEqual(facet.get('values'), [{label: 'V1', value: 0}],
                  "Facet's value should match input");
    });
    test('Toggling a facet which exists with a value which does not should add the value to the facet', function (instance) {
        var field = {};
        var query = new instance.web.search.SearchQuery();
        query.add({category: 'A', field: field, values: [{label: 'V1', value: 0}]});
        query.toggle({category: 'A', field: field, values: [{label: 'V2', value: 1}]});

        equal(query.length, 1, "Should have edited the existing facet");
        var facet = query.at(0);
        equal(facet.values.length, 2, "Should have added the value to the existing facet");
        deepEqual(facet.get('values'), [
            {label: 'V1', value: 0},
            {label: 'V2', value: 1}
        ]);
    });
    test('Toggling a facet which exists with a value which does as well should remove the value from the facet', function (instance) {
        var field = {};
        var query = new instance.web.search.SearchQuery();
        query.add({category: 'A', field: field, values: [{label: 'V1', value: 0}]});
        query.add({category: 'A', field: field, values: [{label: 'V2', value: 1}]});

        query.toggle({category: 'A', field: field, values: [{label: 'V2', value: 1}]});

        equal(query.length, 1, 'Should have the same single facet');
        var facet = query.at(0);
        equal(facet.values.length, 1, "Should only have one value left in the facet");
        deepEqual(facet.get('values'), [
            {label: 'V1', value: 0}
        ]);
    });
    test('Toggling off the last value of a facet should remove the facet', function (instance) {
        var field = {};
        var query = new instance.web.search.SearchQuery();
        query.add({category: 'A', field: field, values: [{label: 'V1', value: 0}]});

        query.toggle({category: 'A', field: field, values: [{label: 'V1', value: 0}]});

        equal(query.length, 0, 'Should have removed the facet');
    });
    test('Intermediate emptiness should not remove the facet', function (instance) {
        var field = {};
        var query = new instance.web.search.SearchQuery();
        query.add({category: 'A', field: field, values: [{label: 'V1', value: 0}]});

        query.toggle({category: 'A', field: field, values: [
            {label: 'V1', value: 0},
            {label: 'V2', value: 1}
        ]});

        equal(query.length, 1, 'Should not have removed the facet');
        var facet = query.at(0);
        equal(facet.values.length, 1, "Should have one value");
        deepEqual(facet.get('values'), [
            {label: 'V2', value: 1}
        ]);
    });

    test('Reseting with multiple facets should still work to load defaults', function (instance) {
        var query = new instance.web.search.SearchQuery();
        var field = {};
        query.reset([
            {category: 'A', field: field, values: [{label: 'V1', value: 0}]},
            {category: 'A', field: field, values: [{label: 'V2', value: 1}]}]);

        equal(query.length, 1, 'Should have created a single facet');
        equal(query.at(0).values.length, 2, 'the facet should have merged two values');
        deepEqual(query.at(0).get('values'), [
            {label: 'V1', value: 0},
            {label: 'V2', value: 1}
        ]);
    });
});

/**
 * Builds a basic search view with a single "dummy" field. The dummy
 * extends `instance.web.search.Field`, it does not add any (class)
 * attributes beyond what is provided through ``dummy_widget_attributes``.
 *
 * The view is returned un-started, it is the caller's role to start it
 * (or use DOM-insertion methods to start it indirectly).
 *
 * @param instance
 * @param [dummy_widget_attributes={}]
 * @param [defaults={}]
 * @return {instance.web.SearchView}
 */
var makeSearchView = function (instance, dummy_widget_attributes, defaults, options) {
    instance.web.search.fields.add(
        'dummy', 'instance.dummy.DummyWidget');
    instance.dummy = {};
    instance.dummy.DummyWidget = instance.web.search.Field.extend(
        dummy_widget_attributes || {});
    if (!('dummy.model:fields_view_get' in instance.session.responses)) {
        instance.session.responses['dummy.model:fields_view_get'] = function () {
            return {
                type: 'search',
                fields: {
                    dummy: {type: 'char', string: "Dummy", searchable: true}
                },
                arch: '<search><field name="dummy" widget="dummy"/></search>'
            };
        };
    }
    instance.session.responses['ir.filters:get_filters'] = function () {
        return [];
    };
    instance.session.responses['dummy.model:fields_get'] = function () {
        return {
            dummy: {type: 'char', string: 'Dummy', searchable: true}
        };
    };
    instance.client = { action_manager: { inner_action: undefined } };

    var dataset = new instance.web.DataSet(null, 'dummy.model');
    var mock_parent = {getParent: function () {return null;}};
    options = _.defaults(options || {}, {$buttons: $('<div>')});
    var view = new instance.web.SearchView(mock_parent, dataset, false, defaults, options);
    var self = this;
    view.on('invalid_search', self, function () {
        ok(false, JSON.stringify([].slice(arguments)));
    });
    return view;
};
openerp.testing.section('search.defaults', {
    dependencies: ['web.search'],
    rpc: 'mock',
    templates: true,
}, function (test) {
    test('calling', {asserts: 2}, function (instance, $s) {
        var defaults_called = false;

        var view = makeSearchView(instance, {
            facet_for_defaults: function (defaults) {
                defaults_called = true;
                return $.when({
                    field: this,
                    category: 'Dummy',
                    values: [{label: 'dummy', value: defaults.dummy}]
                });
            }
        }, {dummy: 42});
        return view.appendTo($s)
            .done(function () {
                ok(defaults_called, "should have called defaults");
                deepEqual(
                    view.query.toJSON(),
                    [{category: 'Dummy', values: [{label: 'dummy', value: 42}]}],
                    "should have generated a facet with the default value");
            });
    });
    test('FilterGroup', {asserts: 3}, function (instance) {
        var view = {inputs: [], query: {on: function () {}}};
        var filter_a = new instance.web.search.Filter(
            {attrs: {name: 'a'}}, view);
        var filter_b = new instance.web.search.Filter(
            {attrs: {name: 'b'}}, view);
        var group = new instance.web.search.FilterGroup(
            [filter_a, filter_b], view);
        return group.facet_for_defaults({a: true, b: true})
            .done(function (facet) {
                var model = facet;
                if (!(model instanceof instance.web.search.Facet)) {
                    model = new instance.web.search.Facet(facet);
                }
                var values = model.values;
                equal(values.length, 2, 'facet should have two values');
                strictEqual(values.at(0).get('value'), filter_a);
                strictEqual(values.at(1).get('value'), filter_b);
            });
    });
    test('Field', {asserts: 4}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.Field(
            {attrs: {string: 'Dummy', name: 'dummy'}}, {}, view);
        return f.facet_for_defaults({dummy: 42})
            .done(function (facet) {
                var model = facet;
                if (!(model instanceof instance.web.search.Facet)) {
                    model = new instance.web.search.Facet(facet);
                }
                strictEqual(
                    model.get('category'),
                    f.attrs.string,
                    "facet category should be field label");
                strictEqual(
                    model.get('field'), f,
                    "facet field should be field which created default");
                equal(model.values.length, 1, "facet should have a single value");
                deepEqual(
                    model.values.toJSON(),
                    [{label: '42', value: 42}],
                    "facet value should match provided default");
                });
    });
    test('Selection: valid value', {asserts: 4}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.SelectionField(
            {attrs: {name: 'dummy', string: 'Dummy'}},
            {selection: [[1, "Foo"], [2, "Bar"], [3, "Baz"], [4, "Qux"]]},
            view);
        return f.facet_for_defaults({dummy: 3})
            .done(function (facet) {
                var model = facet;
                if (!(model instanceof instance.web.search.Facet)) {
                    model = new instance.web.search.Facet(facet);
                }
                strictEqual(
                    model.get('category'),
                    f.attrs.string,
                    "facet category should be field label");
                strictEqual(
                    model.get('field'), f,
                    "facet field should be field which created default");
                equal(model.values.length, 1, "facet should have a single value");
                deepEqual(
                    model.values.toJSON(),
                    [{label: 'Baz', value: 3}],
                    "facet value should match provided default's selection");
            });
    });
    test('Selection: invalid value', {asserts: 1}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.SelectionField(
            {attrs: {name: 'dummy', string: 'Dummy'}},
            {selection: [[1, "Foo"], [2, "Bar"], [3, "Baz"], [4, "Qux"]]},
            view);
        return f.facet_for_defaults({dummy: 42})
            .done(function (facet) {
                ok(!facet, "an invalid value should result in a not-facet");
            });
    });
    test("M2O default: value", {asserts: 5}, function (instance, $s, mock) {
        var view = {inputs: []}, id = 4;
        var f = new instance.web.search.ManyToOneField(
            {attrs: {name: 'dummy', string: 'Dummy'}},
            {relation: 'dummy.model.name'},
            view);
        mock('dummy.model.name:name_get', function (args) {
            equal(args[0], id);
            return [[id, "DumDumDum"]];
        });
        return f.facet_for_defaults({dummy: id})
            .done(function (facet) {
                var model = facet;
                if (!(model instanceof instance.web.search.Facet)) {
                    model = new instance.web.search.Facet(facet);
                }
                strictEqual(
                    model.get('category'),
                    f.attrs.string,
                    "facet category should be field label");
                strictEqual(
                    model.get('field'), f,
                    "facet field should be field which created default");
                equal(model.values.length, 1, "facet should have a single value");
                deepEqual(
                    model.values.toJSON(),
                    [{label: 'DumDumDum', value: id}],
                    "facet value should match provided default's selection");
            });
    });
    test("M2O default: value array", {asserts: 2}, function (instance, $s, mock) {
        var view = {inputs: []}, id = 5;
        var f = new instance.web.search.ManyToOneField(
            {attrs: {name: 'dummy', string: 'Dummy'}},
            {relation: 'dummy.model.name'},
            view);
        mock('dummy.model.name:name_get', function (args) {
            equal(args[0], id);
            return [[id, "DumDumDum"]];
        });
        return f.facet_for_defaults({dummy: [id]})
        .done(function (facet) {
            var model = facet;
            if (!(model instanceof instance.web.search.Facet)) {
                model = new instance.web.search.Facet(facet);
            }
            deepEqual(
                model.values.toJSON(),
                [{label: "DumDumDum", value: id}],
                "should support default as a singleton");
        });
    });
    test("M2O default: value", {asserts: 1}, function (instance, $s, mock) {
        var view = {inputs: []}, id = 4;
        var f = new instance.web.search.ManyToOneField(
            {attrs: {name: 'dummy', string: 'Dummy'}},
            {relation: 'dummy.model.name'},
            view);
        mock('dummy.model.name:name_get', function () { return []; });
        return f.facet_for_defaults({dummy: id})
            .done(function (facet) {
                ok(!facet, "an invalid m2o default should yield a non-facet");
            });
    });
    test("M2O default: values", {rpc: false}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.ManyToOneField(
            {attrs: {name: 'dummy', string: 'Dummy'}},
            {relation: 'dummy.model.name'},
            view);
        raises(function () { f.facet_for_defaults({dummy: [6, 7]}); },
               "should not accept multiple default values");
    });
});
openerp.testing.section('search.completions', {
    dependencies: ['web.search'],
    rpc: 'mock',
    templates: true
}, function (test) {
    test('calling', {asserts: 4}, function (instance, $s) {
        var view = makeSearchView(instance, {
            complete: function () {
                return $.when({
                    label: "Dummy",
                    facet: {
                        field: this,
                        category: 'Dummy',
                        values: [{label: 'dummy', value: 42}]
                    }
                });
            }
        });
        var done = $.Deferred();
        view.appendTo($s)
            .then(function () {
                view.complete_global_search({term: "dum"}, function (completions) {
                    done.resolve();
                    equal(completions.length, 1, "should have a single completion");
                    var completion = completions[0];
                    equal(completion.label, "Dummy",
                          "should have provided label");
                    equal(completion.facet.category, "Dummy",
                          "should have provided category");
                    deepEqual(completion.facet.values,
                              [{label: 'dummy', value: 42}],
                              "should have provided values");
                });
            }).fail(function () { done.reject.apply(done, arguments); });
        return done;
    });
    test('facet selection', {asserts: 2}, function (instance, $s) {
        var completion = {
            label: "Dummy",
            facet: {
                field: {
                    get_domain: openerp.testing.noop,
                    get_context: openerp.testing.noop,
                    get_groupby: openerp.testing.noop
                },
                category: 'Dummy',
                values: [{label: 'dummy', value: 42}]
            }
        };

        var view = makeSearchView(instance);
        return view.appendTo($s)
            .done(function () {
                view.select_completion(
                    {preventDefault: function () {}},
                    {item: completion});
                equal(view.query.length, 1, "should have one facet in the query");
                deepEqual(
                    view.query.at(0).toJSON(),
                    {category: 'Dummy', values: [{label: 'dummy', value: 42}]},
                    "should have the right facet in the query");
            });
    });
    test('facet selection: new value existing facet', {asserts: 8}, function (instance, $s) {
        var field = {
            get_domain: openerp.testing.noop,
            get_context: openerp.testing.noop,
            get_groupby: openerp.testing.noop
        };
        var completion = {
            label: "Dummy",
            facet: {
                field: field,
                category: 'Dummy',
                values: [{label: 'dummy', value: 42}]
            }
        };

        var view = makeSearchView(instance);
        return view.appendTo($s)
            .done(function () {
                view.query.add({field: field, category: 'Dummy',
                                values: [{label: 'previous', value: 41}]});
                equal(view.query.length, 1, 'should have newly added facet');
                view.select_completion(
                    {preventDefault: function () {}},
                    {item: completion});
                equal(view.query.length, 1, "should still have only one facet");
                var facet = view.query.at(0);
                var values = facet.get('values');
                equal(values.length, 2, 'should have two values');
                equal(values[0].label, 'previous');
                equal(values[0].value, 41);
                equal(values[1].label, 'dummy');
                equal(values[1].value, 42);
                deepEqual(
                    values,
                    [{label: 'previous', value: 41}, {label: 'dummy', value: 42}],
                    "should have added selected value to old one");
            });
    });
    test('Field', {asserts: 1}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.Field({attrs: {}}, {}, view);
        return f.complete('foo')
            .done(function (completions) {
                ok(_(completions).isEmpty(), "field should not provide any completion");
            });
    });
    test('CharField', {asserts: 6}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.CharField(
            {attrs: {string: "Dummy"}}, {}, view);
        return f.complete('foo<')
            .done(function (completions) {
                equal(completions.length, 1, "should provide a single completion");
                var c = completions[0];
                equal(c.label, "Search <em>Dummy</em> for: <strong>foo&lt;</strong>",
                      "should propose a fuzzy matching/searching, with the" +
                      " value escaped");
                ok(c.facet, "completion should contain a facet proposition");
                var facet = new instance.web.search.Facet(c.facet);
                equal(facet.get('category'), f.attrs.string,
                      "completion facet should bear the field's name");
                strictEqual(facet.get('field'), f,
                            "completion facet should yield the field");
                deepEqual(facet.values.toJSON(), [{label: 'foo<', value: 'foo<'}],
                          "facet should have single value using completion item");
            });
    });
    test('Selection: match found', {asserts: 14}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.SelectionField(
            {attrs: {string: "Dummy"}},
            {selection: [[1, "Foo"], [2, "Bar"], [3, "Baz"], [4, "Bazador"]]},
            view);
        return f.complete("ba")
            .done(function (completions) {
                equal(completions.length, 4,
                    "should provide two completions and a section title");
                deepEqual(completions[0], {label: "Dummy"});

                var c1 = completions[1];
                equal(c1.label, "Bar");
                equal(c1.facet.category, f.attrs.string);
                strictEqual(c1.facet.field, f);
                deepEqual(c1.facet.values, [{label: "Bar", value: 2}]);

                var c2 = completions[2];
                equal(c2.label, "Baz");
                equal(c2.facet.category, f.attrs.string);
                strictEqual(c2.facet.field, f);
                deepEqual(c2.facet.values, [{label: "Baz", value: 3}]);

                var c3 = completions[3];
                equal(c3.label, "Bazador");
                equal(c3.facet.category, f.attrs.string);
                strictEqual(c3.facet.field, f);
                deepEqual(c3.facet.values, [{label: "Bazador", value: 4}]);
            });
    });
    test('Selection: no match', {asserts: 1}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.SelectionField(
            {attrs: {string: "Dummy"}},
            {selection: [[1, "Foo"], [2, "Bar"], [3, "Baz"], [4, "Bazador"]]},
            view);
        return f.complete("qux")
            .done(function (completions) {
                ok(!completions, "if no value matches the needle, no completion shall be provided");
            });
    });
    test('Date', {asserts: 6}, function (instance) {
        instance.web._t.database.parameters = {
            date_format: '%Y-%m-%d',
            time_format: '%H:%M:%S'
        };
        var view = {inputs: []};
        var f = new instance.web.search.DateField(
            {attrs: {string: "Dummy"}}, {type: 'datetime'}, view);
        return f.complete('2012-05-21T21:21:21')
            .done(function (completions) {
                equal(completions.length, 1, "should provide a single completion");
                var c = completions[0];
                equal(c.label, "Search <em>Dummy</em> at: <strong>2012-05-21 21:21:21</strong>");
                var facet = new instance.web.search.Facet(c.facet);
                equal(facet.get('category'), f.attrs.string);
                equal(facet.get('field'), f);
                var value = facet.values.at(0);
                equal(value.get('label'), "2012-05-21 21:21:21");
                equal(value.get('value').getTime(),
                      new Date(2012, 4, 21, 21, 21, 21).getTime());
            });
    });
    test("M2O complete", {asserts: 4}, function (instance, $s, mock) {
        var view = {inputs: [], dataset: {get_context: function () {}}};
        var f = new instance.web.search.ManyToOneField(
            {attrs: {string: 'Dummy'}}, {relation: 'dummy.model'}, view);
        return f.complete("bob")
            .done(function (c) {
                equal(c.length, 1, "should return one line");
                var bob = c[0];
                ok(bob.expand, "should return an expand callback");
                ok(bob.facet, "should have a facet");
                ok(bob.label, "should have a label");
            });
    });
    test("M2O expand", {asserts: 11}, function (instance, $s, mock) {
        mock('dummy.model:name_search', function (args, kwargs) {
            deepEqual(args, []);
            strictEqual(kwargs.name, 'bob');
            return [[42, "choice 1"], [43, "choice @"]];
        });

        var view = {inputs: [], dataset: {get_context: function () {}}};
        var f = new instance.web.search.ManyToOneField(
            {attrs: {string: 'Dummy'}}, {relation: 'dummy.model'}, view);
        return f.expand("bob")
            .done(function (c) {
                equal(c.length, 2, "should return results");

                var f1 = new instance.web.search.Facet(c[0].facet);
                equal(c[0].label, "choice 1");
                equal(f1.get('category'), f.attrs.string);
                equal(f1.get('field'), f);
                deepEqual(f1.values.toJSON(), [{label: 'choice 1', value: 42}]);

                var f2 = new instance.web.search.Facet(c[1].facet);
                equal(c[1].label, "choice @");
                equal(f2.get('category'), f.attrs.string);
                equal(f2.get('field'), f);
                deepEqual(f2.values.toJSON(), [{label: 'choice @', value: 43}]);
            });
    });
    test("M2O no match", {asserts: 3}, function (instance, $s, mock) {
        mock('dummy.model:name_search', function (args, kwargs) {
            deepEqual(args, []);
            strictEqual(kwargs.name, 'bob');
            return [];
        });
        var view = {inputs: [], dataset: {get_context: function () {}}};
        var f = new instance.web.search.ManyToOneField(
            {attrs: {string: 'Dummy'}}, {relation: 'dummy.model'}, view);
        return f.expand("bob")
            .done(function (c) {
                ok(!c, "no match should yield no completion");
            });
    });
    test("M2O filtered", {asserts: 2}, function (instance, $s, mock) {
        mock('dummy.model:name_search', function (args, kwargs) {
            deepEqual(args, [], "should have no positional arguments");
            deepEqual(kwargs, {
                name: 'bob',
                limit: 8,
                args: [['foo', '=', 'bar']],
                context: {flag: 1},
            }, "should use filtering domain");
            return [[42, "Match"]];
        });
        var view = {
            inputs: [],
            dataset: {get_context: function () { return {flag: 1}; }}
        };
        var f = new instance.web.search.ManyToOneField(
            {attrs: {string: 'Dummy', domain: [["foo", "=", "bar"]]}},
            {relation: 'dummy.model'}, view);
        return f.expand("bob");
    });
    test("M2O custom operator", {asserts: 8}, function (instance, $s, mock) {
        mock('dummy.model:name_search', function (args, kwargs) {
            deepEqual(args, [], "should have no positional arguments");
            // the operator is meant for the final search term generation, not the autocompletion
            equal(kwargs.operator, undefined, "operator should not be used for autocompletion")
            strictEqual(kwargs.name, 'bob');
            return [[42, "Match"]];
        });
        var view = {inputs: [], dataset: {get_context: function () {}}};
        var f = new instance.web.search.ManyToOneField(
            {attrs: {string: 'Dummy', operator: 'ilike'}},
            {relation: 'dummy.model'}, view);

        return f.expand('bob')
            .done(function (c) {
                equal(c.length, 1, "should return result");

                var f1 = new instance.web.search.Facet(c[0].facet);
                equal(c[0].label, "Match");
                equal(f1.get('category'), f.attrs.string);
                equal(f1.get('field'), f);
                deepEqual(f1.values.toJSON(), [{label: 'Match', value: 42}]);
            });
    });
    test('Integer: invalid', {asserts: 1}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.IntegerField(
            {attrs: {string: "Dummy"}}, {}, view);
        return f.complete("qux")
            .done(function (completions) {
                ok(!completions, "non-number => no completion");
            });
    });
    test('Integer: non-zero', {asserts: 5}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.IntegerField(
            {attrs: {string: "Dummy"}}, {}, view);
        return f.complete("-2")
            .done(function (completions) {
                equal(completions.length, 1, "number fields provide 1 completion only");
                var facet = new instance.web.search.Facet(completions[0].facet);
                equal(facet.get('category'), f.attrs.string);
                equal(facet.get('field'), f);
                var value = facet.values.at(0);
                equal(value.get('label'), "-2");
                equal(value.get('value'), -2);
            });
    });
    test('Integer: zero', {asserts: 3}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.IntegerField(
            {attrs: {string: "Dummy"}}, {}, view);
        return f.complete("0")
            .done(function (completions) {
                equal(completions.length, 1, "number fields provide 1 completion only");
                var facet = new instance.web.search.Facet(completions[0].facet);
                var value = facet.values.at(0);
                equal(value.get('label'), "0");
                equal(value.get('value'), 0);
            });
    });
    test('Float: non-zero', {asserts: 5}, function (instance) {
        var view = {inputs: []};
        var f = new instance.web.search.FloatField(
            {attrs: {string: "Dummy"}}, {}, view);
        return f.complete("42.37")
            .done(function (completions) {
                equal(completions.length, 1, "float fields provide 1 completion only");
                var facet = new instance.web.search.Facet(completions[0].facet);
                equal(facet.get('category'), f.attrs.string);
                equal(facet.get('field'), f);
                var value = facet.values.at(0);
                equal(value.get('label'), "42.37");
                equal(value.get('value'), 42.37);
            });
    });
    
});
openerp.testing.section('search.serialization', {
    dependencies: ['web.search'],
    rpc: 'mock',
    templates: true
}, function (test) {
    test('No facet, no call', {asserts: 6}, function (instance, $s) {
        var got_domain = false, got_context = false, got_groupby = false;
        var view = makeSearchView(instance, {
            get_domain: function () {
                got_domain = true;
                return null;
            },
            get_context: function () {
                got_context = true;
                return null;
            },
            get_groupby: function () {
                got_groupby = true;
                return null;
            }
        });
        var ds, cs, gs;
        view.on('search_data', this, function (d, c, g) {
            ds = d; cs = c; gs = g;
        });
        return view.appendTo($s)
            .done(function () {
                view.do_search();
                ok(!got_domain, "no facet, should not have fetched domain");
                ok(_(ds).isEmpty(), "domains list should be empty");

                ok(!got_context, "no facet, should not have fetched context");
                ok(_(cs).isEmpty(), "contexts list should be empty");

                ok(!got_groupby, "no facet, should not have fetched groupby");
                ok(_(gs).isEmpty(), "groupby list should be empty");
            });
    });
    test('London, calling', {asserts: 8}, function (instance, $fix) {
        var got_domain = false, got_context = false, got_groupby = false;
        var view = makeSearchView(instance, {
            get_domain: function (facet) {
                equal(facet.get('category'), "Dummy");
                deepEqual(facet.values.toJSON(), [{label: "42", value: 42}]);
                got_domain = true;
                return null;
            },
            get_context: function () {
                got_context = true;
                return null;
            },
            get_groupby: function () {
                got_groupby = true;
                return null;
            }
        }, {dummy: 42});
        var ds, cs, gs;
        view.on('search_data', this, function (d, c, g) {
            ds = d; cs = c; gs = g;
        });
        return view.appendTo($fix)
            .done(function () {
                view.do_search();
                ok(got_domain, "should have fetched domain");
                ok(_(ds).isEmpty(), "domains list should be empty");

                ok(got_context, "should have fetched context");
                ok(_(cs).isEmpty(), "contexts list should be empty");

                ok(got_groupby, "should have fetched groupby");
                ok(_(gs).isEmpty(), "groupby list should be empty");
            });
    });
    test('Generate domains', {asserts: 1}, function (instance, $fix) {
        var view = makeSearchView(instance, {
            get_domain: function (facet) {
                return facet.values.map(function (value) {
                    return ['win', '4', value.get('value')];
                });
            }
        }, {dummy: 42});
        var ds;
        view.on('search_data', this, function (d) { ds = d; });
        return view.appendTo($fix)
            .done(function () {
                view.do_search();
                deepEqual(ds, [[['win', '4', 42]]],
                    "search should yield an array of contexts");
            });
    });

    test('Field single value, default domain & context', {
        rpc: false
    }, function (instance) {
        var f = new instance.web.search.Field({}, {name: 'foo'}, {inputs: []});
        var facet = new instance.web.search.Facet({
            field: f,
            values: [{value: 42}]
        });

        deepEqual(f.get_domain(facet), [['foo', '=', 42]],
            "default field domain is a strict equality of name to facet's value");
        equal(f.get_context(facet), null,
            "default field context is null");
    });
    test('Field multiple values, default domain & context', {
        rpc: false
    }, function (instance) {
        var f = new instance.web.search.Field({}, {name: 'foo'}, {inputs: []});
        var facet = new instance.web.search.Facet({
            field: f,
            values: [{value: 42}, {value: 68}, {value: 999}]
        });

        var actual_domain = f.get_domain(facet);
        equal(actual_domain.__ref, "compound_domain",
              "multiple value should yield compound domain");
        deepEqual(actual_domain.__domains, [
                    ['|'],
                    ['|'],
                    [['foo', '=', 42]],
                    [['foo', '=', 68]],
                    [['foo', '=', 999]]
            ],
            "domain should OR a default domain for each value");
        equal(f.get_context(facet), null,
            "default field context is null");
    });
    test('Field single value, custom domain & context', {
        rpc: false
    }, function (instance) {
        var f = new instance.web.search.Field({attrs:{
            context: "{'bob': self}",
            filter_domain: "[['edmund', 'is', self]]"
        }}, {name: 'foo'}, {inputs: []});
        var facet = new instance.web.search.Facet({
            field: f,
            values: [{value: "great"}]
        });

        var actual_domain = f.get_domain(facet);
        equal(actual_domain.__ref, "compound_domain",
              "@filter_domain should yield compound domain");
        deepEqual(actual_domain.__domains, [
            "[['edmund', 'is', self]]"
        ], 'should hold unevaluated custom domain');
        deepEqual(actual_domain.get_eval_context(), {
            self: "great"
        }, "evaluation context should hold facet value as self");

        var actual_context = f.get_context(facet);
        equal(actual_context.__ref, "compound_context",
              "@context should yield compound context");
        deepEqual(actual_context.__contexts, [
            "{'bob': self}"
        ], 'should hold unevaluated custom context');
        deepEqual(actual_context.get_eval_context(), {
            self: "great"
        }, "evaluation context should hold facet value as self");
    });
    test("M2O default", {
        rpc: false
    }, function (instance) {
        var f = new instance.web.search.ManyToOneField(
            {}, {name: 'foo'}, {inputs: []});
        var facet = new instance.web.search.Facet({
            field: f,
            values: [{label: "Foo", value: 42}]
        });

        deepEqual(f.get_domain(facet), [['foo', '=', 42]],
            "m2o should use identity if default domain");
        deepEqual(f.get_context(facet), {default_foo: 42},
            "m2o should use value as context default");
    });
    test("M2O default multiple values", {
        rpc: false
    }, function (instance) {
        var f = new instance.web.search.ManyToOneField(
            {}, {name: 'foo'}, {inputs: []});
        var facet = new instance.web.search.Facet({
            field: f,
            values: [
                {label: "Foo", value: 42},
                {label: "Bar", value: 36}
            ]
        });

        deepEqual(f.get_domain(facet).__domains,
            [['|'], [['foo', '=', 42]], [['foo', '=', 36]]],
            "m2o should or multiple values");
        equal(f.get_context(facet), null,
            "m2o should not have default context in case of multiple values");
    });
    test("M2O custom operator", {
        rpc: false
    }, function (instance) {
        var f = new instance.web.search.ManyToOneField(
            {attrs: {operator: 'boos'}}, {name: 'foo'}, {inputs: []});
        var facet = new instance.web.search.Facet({
            field: f,
            values: [{label: "Foo", value: 42}]
        });

        deepEqual(f.get_domain(facet), [['foo', 'boos', 'Foo']],
            "m2o should use label with custom operators");
        deepEqual(f.get_context(facet), {default_foo: 42},
            "m2o should use value as context default");
    });
    test("M2O custom domain & context", {
        rpc: false
    }, function (instance) {
        var f = new instance.web.search.ManyToOneField({attrs: {
            context: "{'whee': self}",
            filter_domain: "[['filter', 'is', self]]"
        }}, {name: 'foo'}, {inputs: []});
        var facet = new instance.web.search.Facet({
            field: f,
            values: [{label: "Foo", value: 42}]
        });

        var domain = f.get_domain(facet);
        deepEqual(domain.__domains, [
            "[['filter', 'is', self]]"
        ]);
        deepEqual(domain.get_eval_context(), {
            self: "Foo"
        }, "custom domain's self should be label");
        var context = f.get_context(facet);
        deepEqual(context.__contexts, [
            "{'whee': self}"
        ]);
        deepEqual(context.get_eval_context(), {
            self: "Foo"
        }, "custom context's self should be label");
    });

    test('FilterGroup', {asserts: 6}, function (instance) {
        var view = {inputs: [], query: {on: function () {}}};
        var filter_a = new instance.web.search.Filter(
            {attrs: {name: 'a', context: '{"c1": True}', domain: 'd1'}}, view);
        var filter_b = new instance.web.search.Filter(
            {attrs: {name: 'b', context: '{"c2": True}', domain: 'd2'}}, view);
        var filter_c = new instance.web.search.Filter(
            {attrs: {name: 'c', context: '{"c3": True}', domain: 'd3'}}, view);
        var group = new instance.web.search.FilterGroup(
            [filter_a, filter_b, filter_c], view);
        return group.facet_for_defaults({a: true, c: true})
            .done(function (facet) {
                var model = facet;
                if (!(model instanceof instance.web.search.Facet)) {
                    model = new instance.web.search.Facet(facet);
                }

                var domain = group.get_domain(model);
                equal(domain.__ref, 'compound_domain',
                    "domain should be compound");
                deepEqual(domain.__domains, [
                    ['|'], 'd1', 'd3'
                ], "domain should OR filter domains");
                ok(!domain.get_eval_context(), "domain should have no evaluation context");
                var context = group.get_context(model);
                equal(context.__ref, 'compound_context',
                    "context should be compound");
                deepEqual(context.__contexts, [
                    '{"c1": True}', '{"c3": True}'
                ], "context should merge all filter contexts");
                ok(!context.get_eval_context(), "context should have no evaluation context");
            });
    });
    test('Empty filter domains', {asserts: 4}, function (instance) {
        var view = {inputs: [], query: {on: function () {}}};
        var filter_a = new instance.web.search.Filter(
            {attrs: {name: 'a', context: '{}', domain: '[]'}}, view);
        var filter_b = new instance.web.search.Filter(
            {attrs: {name: 'b', context: '{}', domain: '[]'}}, view);
        var filter_c = new instance.web.search.Filter(
            {attrs: {name: 'c', context: '{b: 42}', domain: '[["a", "=", 3]]'}}, view);
        var group = new instance.web.search.FilterGroup(
            [filter_a, filter_b, filter_c], view);
        var t1 = group.facet_for_defaults({a: true, c: true})
        .done(function (facet) {
            var model = facet;
            if (!(model instanceof instance.web.search.Facet)) {
                model = new instance.web.search.Facet(facet);
            }

            var domain = group.get_domain(model);
            deepEqual(domain, '[["a", "=", 3]]', "domain should ignore empties");
            var context = group.get_context(model);
            deepEqual(context, '{b: 42}', "context should ignore empties");
        });
        var t2 = group.facet_for_defaults({a: true, b: true})
        .done(function (facet) {
            var model = facet;
            if (!(model instanceof instance.web.search.Facet)) {
                model = new instance.web.search.Facet(facet);
            }

            var domain = group.get_domain(model);
            equal(domain, null, "domain should ignore empties");
            var context = group.get_context(model);
            equal(context, null, "context should ignore empties");
        });
        return $.when(t1, t2);
    });
});
openerp.testing.section('search.menus', {
    dependencies: ['web.search'],
    rpc: 'mock',
    templates: true
}, function (test) {
    test('is-drawn', {asserts: 3}, function (instance, $fix) {
        var view = makeSearchView(instance, false, false, {$buttons: $('<div>')});
        return view.appendTo($fix)
            .done(function () {
                ok(view.$buttons.find('.filters-menu').length,
                   "filters menu has been drawn");
                ok(view.$buttons.find('.group-by-menu').length,
                   "group by menu has been drawn");
                ok(view.$buttons.find('.favorites-menu').length,
                   "favorites menu has been drawn");
            });
    });
});
openerp.testing.section('search.filters', {
    dependencies: ['web.search'],
    rpc: 'mock',
    templates: true,
    setup: function (instance, $s, mock) {
        mock('dummy.model:fields_view_get', function () {
            // view with a single group of filters
            return {
                type: 'search',
                fields: {},
                arch: '<search>' +
                        '<filter string="Foo1" domain="[ [\'foo\', \'=\', \'1\'] ]"/>' +
                        '<filter name="foo2" string="Foo2" domain="[ [\'foo\', \'=\', \'2\'] ]"/>' +
                        '<filter string="Foo3" domain="[ [\'foo\', \'=\', \'3\'] ]"/>' +
                        '</search>',
            };
        });
    }
}, function (test) {
    test('drawn', {asserts: 4}, function (instance, $fix) {
        var view = makeSearchView(instance);
        return view.appendTo($fix)
            .done(function () {
                var $filters = view.$buttons.find('.filters-menu li'),
                    $favorites = view.$buttons.find('.favorites-menu li'),
                    $groupby = view.$buttons.find('.group-by-menu li');
                // 3 filters, 1 separator, 1 button add filter, 
                // 1 filter condition menu, 1 apply button
                equal($filters.length, 7,
                      'filter menu should have 7 elements total');
                // 1 divider, 1 save search button, 1 text input, 2 checkboxes, 
                // 1 save button 
                equal($favorites.length, 6,
                      "favorites menu should have 6 elements");
                // 1 divider, 1 add custom group button, 1 select groupby, 1 apply button,
                equal($groupby.length, 4,
                      "groupby menu should have 4 element");
                equal(_.str.strip($filters.find('a')[0].textContent), "Foo1",
                      "Text content of first filter option should match filter string");
            });
    });
    test('click adding from empty query', {asserts: 4}, function (instance, $fix) {
        var view = makeSearchView(instance);
        return view.appendTo($fix)
            .done(function () {
                var $fs = view.$buttons.find('.filters-menu li a');
                $fs.eq(2).trigger('click');
                equal(view.query.length, 1, "click should have added a facet");
                var facet = view.query.at(0);
                equal(facet.values.length, 1, "facet should have a single value");
                var value = facet.values.at(0);
                ok(value.get('value') instanceof instance.web.search.Filter,
                   "value should be a filter");
                equal(value.get('label'), "Foo3",
                      "value should be third filter");
            });
    });
    test('click adding from existing query', {asserts: 4}, function (instance, $fix) {
        var view = makeSearchView(instance, {}, {foo2: true});
        return view.appendTo($fix)
            .done(function () {
                var $fs = view.$buttons.find('.filters-menu li a');
                $fs.eq(2).trigger('click');
                equal(view.query.length, 1, "click should not have changed facet count");
                var facet = view.query.at(0);
                equal(facet.values.length, 2, "facet should have a second value");
                var v1 = facet.values.at(0);
                equal(v1.get('label'), "Foo2",
                      "first value should be default");
                var v2 = facet.values.at(1);
                equal(v2.get('label'), "Foo3",
                      "second value should be clicked filter");
            });
    });
    test('click removing from query', {asserts: 4}, function (instance, $fix) {
        var calls = 0;
        var view = makeSearchView(instance, {}, {foo2: true});
        view.on('search_data', null, function () {
            ++calls;
        });
        return view.appendTo($fix)
            .done(function () {
                var $fs = view.$buttons.find('.filters-menu li a');
                // sanity check
                equal(view.query.length, 1, "query should have default facet");
                strictEqual(calls, 0);
                $fs.eq(1).trigger('click');
                equal(view.query.length, 0, "click should have removed facet");
                strictEqual(calls, 1, "one search should have been triggered");
            });
    });
});
openerp.testing.section('search.groupby', {
    dependencies: ['web.search'],
    rpc: 'mock',
    templates: true,
}, function (test) {
    test('basic', {
        asserts: 12,
        setup: function (instance, $s, mock) {
            mock('dummy.model:fields_view_get', function () {
                return {
                    type: 'search',
                    fields: {},
                    arch: [
                        '<search>',
                            '<filter string="Foo" context="{\'group_by\': \'foo\'}"/>',
                            '<filter string="Bar" context="{\'group_by\': \'bar\'}"/>',
                            '<filter string="Baz" context="{\'group_by\': \'baz\'}"/>',
                        '</search>'
                    ].join(''),
                };
            });
        }
    }, function (instance, $fix) {
        var view = makeSearchView(instance);
        return view.appendTo($fix)
        .done(function () {
            equal(view.search_fields.length, 0); // 0 fields
            equal(view.filters.length, 0); // 0 filters (in filter menu)
            equal(view.groupbys.length, 1); // 1 group of groupbys
            var group = view.groupbys[0];
            ok(group instanceof instance.web.search.GroupbyGroup, 
                    'should have a GroupbyGroup input');
            equal(group.filters.length, 3); // 3 group bys in group
            ok(group.getParent() === view,
                "group's parent should be the searchview");

            group.toggle(group.filters[0]);
            group.toggle(group.filters[2]);

            var results = view.build_search_data();
            deepEqual(results.domains, [], "should have no domain");
            deepEqual(results.contexts, [
                new instance.web.CompoundContext(
                    "{'group_by': 'foo'}", "{'group_by': 'baz'}")
            ], "should have compound contexts");
            deepEqual(results.groupbys, [
                "{'group_by': 'foo'}",
                "{'group_by': 'baz'}"
            ], "should have sequence of contexts");

            ok(view.filter_menu instanceof instance.web.search.FilterMenu, 'should have a filter menu');
            ok(view.groupby_menu instanceof instance.web.search.GroupByMenu, 'should have a group by menu');
            ok(view.favorite_menu instanceof instance.web.search.FavoriteMenu, 'should have a favorite menu');
        });
    });
    test('unified multiple groupby groups', {
        asserts: 3,
        setup: function (instance, $s, mock) {
            mock('dummy.model:fields_view_get', function () {
                return {
                    type: 'search',
                    fields: {},
                    arch: [
                        '<search>',
                            '<filter string="Foo" context="{\'group_by\': \'foo\'}"/>',
                            '<separator/>',
                            '<filter string="Bar" context="{\'group_by\': \'bar\'}"/>',
                            '<separator/>',
                            '<filter string="Baz" context="{\'group_by\': \'baz\'}"/>',
                        '</search>'
                    ].join(''),
                };
            });
        }
    }, function (instance, $fix) {
        var view = makeSearchView(instance);
        return view.appendTo($fix)
        .done(function () {
            var groups = view.groupbys;
            equal(groups.length, 3, "should have 3 GroupbyGroups");

            groups[0].toggle(groups[0].filters[0]);
            groups[2].toggle(groups[2].filters[0]);
            equal(view.query.length, 1,
                  "should have unified groupby groups in single facet");
            deepEqual(view.build_search_data(), {
                domains: [],
                contexts: [new instance.web.CompoundContext(
                    "{'group_by': 'foo'}", "{'group_by': 'baz'}")],
                groupbys: [ "{'group_by': 'foo'}", "{'group_by': 'baz'}" ],
            }, "should only have contexts & groupbys in search data");
        });
    });
});
openerp.testing.section('search.filters.saved', {
    dependencies: ['web.search'],
    rpc: 'mock',
    templates: true
}, function (test) {
    test('checkboxing', {asserts: 6}, function (instance, $fix, mock) {
        var view = makeSearchView(instance, undefined, undefined, {action: {id: 1}});
        mock('ir.filters:get_filters', function () {
            return [{ name: "filter name", user_id: 42 }];
        });

        return view.appendTo($fix)
            .done(function () {
                var $li = view.favorite_menu.$el.find('li:first').click();

                ok($li.hasClass('selected'), "should check/select the filter's row");
                ok($li.hasClass("oe_searchview_custom_private"),
                    "should have private filter note/class");
                equal(view.query.length, 1, "should have only one facet");
                var values = view.query.at(0).values;
                equal(values.length, 1,
                    "should have only one value in the facet");
                equal(values.at(0).get('label'), 'filter name',
                    "displayed label should be the name of the filter");
                equal(values.at(0).get('value'), null,
                    "should have no value set");
            });
    });
    test('removal', {asserts: 1}, function (instance, $fix, mock) {
        var view = makeSearchView(instance);
        mock('ir.filters:get_filters', function () {
            return [{ name: "filter name", user_id: 42 }];
        });

        return view.appendTo($fix)
            .done(function () {
                var $row = view.favorite_menu.$el.find('li:first').click();

                view.query.remove(view.query.at(0));
                ok(!$row.hasClass('selected'),
                    "should not be checked anymore");
            });
    });
    test('toggling', {asserts: 2}, function (instance, $fix, mock) {
        var view = makeSearchView(instance, undefined, undefined, {action: {id: 1}});
        mock('ir.filters:get_filters', function () {
            return [{name: 'filter name', user_id: 42, id: 1}];
        });

        return view.appendTo($fix)
            .done(function () {
                var $row = view.favorite_menu.$el.find('li:first').click();
                equal(view.query.length, 1, "should have one facet");
                $row.click();
                equal(view.query.length, 0, "should have removed facet");
            });
    });
    test('replacement', {asserts: 4}, function (instance, $fix, mock) {
        var view = makeSearchView(instance, undefined, undefined, {action: {id: 1}});
        mock('ir.filters:get_filters', function () {
            return [
                {name: 'f', user_id: 42, id: 1, context: {'private': 1}},
                {name: 'f', user_id: false, id: 2, context: {'private': 0}}
            ];
        });
        return view.appendTo($fix)
            .done(function () {
                view.favorite_menu.$el.find('li:first').click();
                equal(view.query.length, 1, "should have one facet");
                deepEqual(
                    view.query.at(0).get('field').get_context(),
                    {'private': 1},
                    "should have selected first filter");
                view.favorite_menu.$el.find('li').eq(1).click();
                equal(view.query.length, 1, "should have one facet");
                deepEqual(
                    view.query.at(0).get('field').get_context(),
                    {'private': 0},
                    "should have selected second filter");
            });
    });
    test('creation', {asserts: 2}, function (instance, $fix, mock) {
        // force a user context
        instance.session.user_context = {foo: 'bar'};

        var view = makeSearchView(instance);
        var done = $.Deferred();
        mock('ir.filters:get_filters', function () { return []; });
        mock('ir.filters:create_or_replace', function (args) {
            var filter = args[0];
            deepEqual(filter.context, {}, "should have empty context");
            deepEqual(filter.domain, [], "should have empty domain");
            done.resolve();
        });
        return view.appendTo($fix)
        .then(function () {
            view.favorite_menu.$el.find('.oe-save-name input').first().val("filter name");
            view.favorite_menu.$el.find('.oe-save-name button').click();
            return done.promise();
        });
    });
});
openerp.testing.section('search.advanced', {
    dependencies: ['web.search'],
    rpc: 'mock',
    templates: true
}, function (test) {
    test('single-advanced', {asserts: 6}, function (instance, $fix) {
        var view = makeSearchView(instance);

        return view.appendTo($fix)
            .done(function () {
                var $filter_menu = view.filter_menu.$el;
                // open advanced search (not actually useful)
                $filter_menu.find('.oe-add-filter').click();
                // select proposition (only one)
                var $prop = $filter_menu.find('.oe-filter-condition');
                // field select should have two possible values, dummy and id
                equal($prop.find('select:first option').length,
                      2, "advanced search should provide choice between two fields");
                // field should be dummy
                equal($prop.find('select:first').val(),
                      'dummy',
                      "only field should be dummy");
                // operator should be "contains"/'ilike'
                equal($prop.find('.searchview_extended_prop_op').val(),
                      'ilike', "default char operator should be ilike");
                // put value in
                $prop.find('.searchview_extended_prop_value input')
                     .val("stupid value");
                // validate advanced search
                $filter_menu.find('button.oe-apply-filter').click();
                // resulting search
                equal(view.query.length, 1, "search query should have a single facet");
                var facet = view.query.at(0);
                ok(!facet.get('field').get_context(facet),
                   "advanced search facets should yield no context");
                deepEqual(facet.get('field').get_domain(facet),
                          [['dummy', 'ilike', "stupid value"]],
                          "advanced search facet should return proposed domain");
            });
    });
    test('multiple-advanced', {asserts: 3}, function (instance, $fix) {
        var view = makeSearchView(instance);

        return view.appendTo($fix)
            .done(function () {
                var $filter_menu = view.filter_menu.$el;
                // open advanced search (not actually useful)
                $filter_menu.find('.oe-add-filter').click();
                // open second condition
                $filter_menu.find('a.oe-add-condition').click();

                // select first proposition
                var $prop1 = $filter_menu.find('.oe-filter-condition:first');
                $prop1.find('select.searchview_extended_prop_field').val("dummy").change();
                $prop1.find('select.searchview_extended_prop_op').val('ilike');
                $prop1.find('.searchview_extended_prop_value input')
                     .val("stupid value");

                // select first proposition
                var $prop2 = $filter_menu.find('.oe-filter-condition:last');
                // need to trigger event manually or op not changed
                $prop2.find('select.searchview_extended_prop_field').val('id').change();
                $prop2.find('select.searchview_extended_prop_op').val('=');
                $prop2.find('.searchview_extended_prop_value input')
                     .val(42);
                // validate advanced search
                $filter_menu.find('button.oe-apply-filter').click();

                // resulting search
                equal(view.query.length, 1, "search query should have a single facet");
                var facet = view.query.at(0);
                ok(!facet.get('field').get_context(facet),
                   "advanced search facets should yield no context");
                deepEqual(facet.get('field').get_domain(facet).eval(),
                          ['|', ['dummy', 'ilike', "stupid value"],
                                ['id', '=', 42]],
                          "advanced search facet should return proposed domain");
            });
    });
    // TODO: UI tests?
});