← Back to branch summary

~ubuntu-branches/ubuntu/natty/adblock-plus/natty

« back to all changes in this revision

Viewing changes to chrome/content/mochitest/tests/test_filterListener.html

  • Committer: Bazaar Package Importer
  • Author(s): Benjamin Drung
  • Date: 2010-11-05 18:42:36 UTC
  • mto: (25.1.1 sid)
  • mto: This revision was merged to the branch mainline in revision 27.
  • Revision ID: james.westby@ubuntu.com-20101105184236-h7dnu8mbfjaoya62
Tags: upstream-1.3.1
Import upstream version 1.3.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
chrome/content/mochitest/tests/test_filterListener.html
9
9
  <script type="text/javascript" src="/content/tests/SimpleTest/SimpleTest.js"></script>        
10
10
 
11
11
  <script type="application/x-javascript;version=1.7" src="common.js"></script>
12
 
  <script type="application/x-javascript;version=1.7" src="chrome://adblockplus/content/filterClasses.js"></script>
13
 
  <script type="application/x-javascript;version=1.7" src="chrome://adblockplus/content/subscriptionClasses.js"></script>
14
 
  <script type="application/x-javascript;version=1.7" src="chrome://adblockplus/content/filterStorage.js"></script>
15
 
  <script type="application/x-javascript;version=1.7" src="chrome://adblockplus/content/matcher.js"></script>
16
 
  <script type="application/x-javascript;version=1.7" src="chrome://adblockplus/content/elemhide.js"></script>
17
 
  <script type="application/x-javascript;version=1.7" src="chrome://adblockplus/content/filterListener.js"></script>
18
12
</head>
19
13
<body>
20
14
  <p id="display"></p>
23
17
  </div>
24
18
  <pre id="test">
25
19
  <script type="application/x-javascript;version=1.7">
26
 
    var prefs = {
27
 
      enabled: true
28
 
    };
29
 
 
30
 
    filterListener.init();
31
 
 
32
 
    filterStorage.addSubscription(Subscription.fromURL("~fl~"));
33
 
    filterStorage.addSubscription(Subscription.fromURL("~wl~"));
34
 
    filterStorage.addSubscription(Subscription.fromURL("~il~"));
35
 
    filterStorage.addSubscription(Subscription.fromURL("~eh~"));
 
20
    prepareFilterComponents(true);
 
21
    preparePrefs();
 
22
 
 
23
    FilterStorage.addSubscription(Subscription.fromURL("~fl~"));
 
24
    FilterStorage.addSubscription(Subscription.fromURL("~wl~"));
 
25
    FilterStorage.addSubscription(Subscription.fromURL("~il~"));
 
26
    FilterStorage.addSubscription(Subscription.fromURL("~eh~"));
36
27
 
37
28
    function checkKnownFilters(text, expected)
38
29
    {
39
30
      let result = {};
40
 
      for each (let matcher in [blacklistMatcher, whitelistMatcher])
 
31
      for each (let matcher in [defaultMatcher.blacklist, defaultMatcher.whitelist])
41
32
      {
42
33
        let filters = [];
43
34
        for each (let filter in matcher.regexps)
53
44
            is(filter.shortcut, shortcut, "Shortcut of filter " + filter.text);
54
45
          filters.push(filter);
55
46
        }
56
 
        result[matcher == blacklistMatcher ? "blacklist" : "whitelist"] = filters;
 
47
        result[matcher == defaultMatcher.blacklist ? "blacklist" : "whitelist"] = filters;
57
48
      }
58
 
      result.elemhide = elemhide.filters;
 
49
      result.elemhide = ElemHideGlobal.filters;
59
50
 
60
51
      function canonize(obj)
61
52
      {
85
76
    let filter3 = Filter.fromText("#filter3");
86
77
    let filter4 = Filter.fromText("!filter4");
87
78
 
88
 
    filterStorage.addFilter(filter1);
 
79
    FilterStorage.addFilter(filter1);
89
80
    checkKnownFilters("add filter1", {blacklist: [filter1]});
90
 
    filterStorage.addFilter(filter2);
 
81
    FilterStorage.addFilter(filter2);
91
82
    checkKnownFilters("add filter2", {blacklist: [filter1], whitelist: [filter2]});
92
 
    filterStorage.addFilter(filter3);
 
83
    FilterStorage.addFilter(filter3);
93
84
    checkKnownFilters("add filter3", {blacklist: [filter1], whitelist: [filter2], elemhide: [filter3]});
94
 
    filterStorage.addFilter(filter4);
 
85
    FilterStorage.addFilter(filter4);
95
86
    checkKnownFilters("add filter4", {blacklist: [filter1], whitelist: [filter2], elemhide: [filter3]});
96
87
 
97
 
    filterStorage.removeFilter(filter1);
 
88
    FilterStorage.removeFilter(filter1);
98
89
    checkKnownFilters("remove filter1", {whitelist: [filter2], elemhide: [filter3]});
99
90
    filter2.disabled = true;
100
 
    filterStorage.triggerFilterObservers("disable", [filter2]);
 
91
    FilterStorage.triggerFilterObservers("disable", [filter2]);
101
92
    checkKnownFilters("disable filter2", {elemhide: [filter3]});
102
 
    filterStorage.removeFilter(filter2);
 
93
    FilterStorage.removeFilter(filter2);
103
94
    checkKnownFilters("remove filter2", {elemhide: [filter3]});
104
 
    filterStorage.removeFilter(filter4);
 
95
    FilterStorage.removeFilter(filter4);
105
96
    checkKnownFilters("remove filter4", {elemhide: [filter3]});
106
97
 
107
98
    let subscription = Subscription.fromURL("http://test1/");
108
99
    subscription.filters = [filter1, filter2, filter3, filter4];
109
100
 
110
 
    filterStorage.addSubscription(subscription);
 
101
    FilterStorage.addSubscription(subscription);
111
102
    checkKnownFilters("add subscription with filter1, filter2, filter3, filter4", {blacklist: [filter1], elemhide: [filter3]});
112
103
    filter2.disabled = false;
113
 
    filterStorage.triggerFilterObservers("enable", [filter2]);
 
104
    FilterStorage.triggerFilterObservers("enable", [filter2]);
114
105
    checkKnownFilters("enable filter2", {blacklist: [filter1], whitelist: [filter2], elemhide: [filter3]});
115
 
    filterStorage.updateSubscriptionFilters(subscription, [filter4]);
 
106
    FilterStorage.updateSubscriptionFilters(subscription, [filter4]);
116
107
    checkKnownFilters("change subscription filters to filter4", {elemhide: [filter3]});
117
 
    filterStorage.removeFilter(filter3);
 
108
    FilterStorage.removeFilter(filter3);
118
109
    checkKnownFilters("remove filter3", {});
119
 
    filterStorage.updateSubscriptionFilters(subscription, [filter1, filter2]);
 
110
    FilterStorage.updateSubscriptionFilters(subscription, [filter1, filter2]);
120
111
    checkKnownFilters("change subscription filters to filter1, filter2", {blacklist: [filter1], whitelist: [filter2]});
121
 
    filterStorage.addFilter(filter1);
 
112
    FilterStorage.addFilter(filter1);
122
113
    checkKnownFilters("add filter1", {blacklist: [filter1], whitelist: [filter2]});
123
114
 
124
115
    filter1.disabled = true;
125
 
    filterStorage.triggerFilterObservers("disable", [filter1]);
 
116
    FilterStorage.triggerFilterObservers("disable", [filter1]);
126
117
    checkKnownFilters("disable filter1", {whitelist: [filter2]});
127
118
    filter2.disabled = true;
128
 
    filterStorage.triggerFilterObservers("disable", [filter2]);
 
119
    FilterStorage.triggerFilterObservers("disable", [filter2]);
129
120
    checkKnownFilters("disable filter2", {});
130
121
    filter1.disabled = false;
131
122
    filter2.disabled = false;
132
 
    filterStorage.triggerFilterObservers("enable", [filter1, filter2]);
 
123
    FilterStorage.triggerFilterObservers("enable", [filter1, filter2]);
133
124
    checkKnownFilters("enable filter1, filter2", {blacklist: [filter1], whitelist: [filter2]});
134
125
 
135
126
    subscription.disabled = true;
136
 
    filterStorage.triggerSubscriptionObservers("disable", [subscription]);
 
127
    FilterStorage.triggerSubscriptionObservers("disable", [subscription]);
137
128
    checkKnownFilters("disable subscription", {blacklist: [filter1]});
138
 
    filterStorage.removeSubscription(subscription);
 
129
    FilterStorage.removeSubscription(subscription);
139
130
    checkKnownFilters("remove subscription", {blacklist: [filter1]});
140
 
    filterStorage.addSubscription(subscription);
 
131
    FilterStorage.addSubscription(subscription);
141
132
    checkKnownFilters("add subscription", {blacklist: [filter1]});
142
133
    subscription.disabled = false;
143
 
    filterStorage.triggerSubscriptionObservers("enable", [subscription]);
 
134
    FilterStorage.triggerSubscriptionObservers("enable", [subscription]);
 
135
    checkKnownFilters("enable subscription", {blacklist: [filter1], whitelist: [filter2]});
 
136
 
 
137
    subscription.disabled = true;
 
138
    FilterStorage.triggerSubscriptionObservers("disable", [subscription]);
 
139
    checkKnownFilters("disable subscription", {blacklist: [filter1]});
 
140
    FilterStorage.addFilter(filter2);
 
141
    checkKnownFilters("add filter2", {blacklist: [filter1], whitelist: [filter2]});
 
142
    FilterStorage.removeFilter(filter2);
 
143
    checkKnownFilters("remove filter2", {blacklist: [filter1]});
 
144
    subscription.disabled = false;
 
145
    FilterStorage.triggerSubscriptionObservers("enable", [subscription]);
144
146
    checkKnownFilters("enable subscription", {blacklist: [filter1], whitelist: [filter2]});
145
147
 
146
148
    let subscription2 = Subscription.fromURL("~fl~");
147
149
    subscription2.disabled = true;
148
 
    filterStorage.triggerSubscriptionObservers("disable", [subscription2]);
 
150
    FilterStorage.triggerSubscriptionObservers("disable", [subscription2]);
149
151
    checkKnownFilters("disable blocking filters", {blacklist: [filter1], whitelist: [filter2]});
150
 
    filterStorage.removeSubscription(subscription);
 
152
    FilterStorage.removeSubscription(subscription);
151
153
    checkKnownFilters("remove subscription", {});
152
154
    subscription2.disabled = false;
153
 
    filterStorage.triggerSubscriptionObservers("enable", [subscription2]);
 
155
    FilterStorage.triggerSubscriptionObservers("enable", [subscription2]);
154
156
    checkKnownFilters("enable blocking filters", {blacklist: [filter1]});
155
157
 
156
158
    let subscription3 = Subscription.fromURL("~wl~");
157
159
    subscription3.disabled = true;
158
 
    filterStorage.triggerSubscriptionObservers("disable", [subscription3]);
 
160
    FilterStorage.triggerSubscriptionObservers("disable", [subscription3]);
159
161
    checkKnownFilters("disable exception rules", {blacklist: [filter1]});
160
 
    filterStorage.addFilter(filter2);
 
162
    FilterStorage.addFilter(filter2);
161
163
    checkKnownFilters("add filter2", {blacklist: [filter1]});
162
164
    subscription3.disabled = false;
163
 
    filterStorage.triggerSubscriptionObservers("enable", [subscription3]);
 
165
    FilterStorage.triggerSubscriptionObservers("enable", [subscription3]);
164
166
    checkKnownFilters("enable exception rules", {blacklist: [filter1], whitelist: [filter2]});
165
167
 
166
168
    let subscription4 = Subscription.fromURL("http://test/");
167
169
    let filter5 = Filter.fromText("filter5");
168
170
    let filter6 = Filter.fromText("@@filter6");
169
171
    let filter7 = Filter.fromText("!filter7");
170
 
    filterStorage.updateSubscriptionFilters(subscription4, [filter5, filter6, filter7]);
 
172
    FilterStorage.updateSubscriptionFilters(subscription4, [filter5, filter6, filter7]);
171
173
    checkKnownFilters("update subscription not in the list yet", {blacklist: [filter1], whitelist: [filter2]});
172
174
 
173
 
    filterStorage.addSubscription(subscription4);
 
175
    FilterStorage.addSubscription(subscription4);
174
176
    checkKnownFilters("add subscription to the list", {blacklist: [filter1, filter5], whitelist: [filter2, filter6]});
175
177
 
176
 
    filterStorage.updateSubscriptionFilters(subscription4, [filter5, filter2, filter7]);
 
178
    FilterStorage.updateSubscriptionFilters(subscription4, [filter5, filter2, filter7]);
177
179
    checkKnownFilters("update subscription while in the list", {blacklist: [filter1, filter5], whitelist: [filter2]});
178
180
 
179
181
    subscription3.disabled = true;
180
 
    filterStorage.triggerSubscriptionObservers("disable", [subscription3]);
 
182
    FilterStorage.triggerSubscriptionObservers("disable", [subscription3]);
181
183
    checkKnownFilters("disable exception rules", {blacklist: [filter1, filter5], whitelist: [filter2]});
182
184
 
183
 
    filterStorage.removeSubscription(subscription4);
 
185
    FilterStorage.removeSubscription(subscription4);
184
186
    checkKnownFilters("remove subscription from the list", {blacklist: [filter1]});
185
187
 
186
188
    subscription3.disabled = false;
187
 
    filterStorage.triggerSubscriptionObservers("enable", [subscription3]);
 
189
    FilterStorage.triggerSubscriptionObservers("enable", [subscription3]);
188
190
    checkKnownFilters("enable exception rules", {blacklist: [filter1], whitelist: [filter2]});
189
191
  </script>
190
192
  </pre>
191
193
</body>
192
 
</html>
 
 
b'\\ No newline at end of file'
 
194
</html>