vanitasvitae
/
Smack
mirror of https://github.com/vanitasvitae/Smack.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Add support for XEP-0333: Chat Markers 

Fixes SMACK-736
This commit is contained in:
Fernando Ramirez 2016-11-01 13:51:04 -03:00 committed by Florian Schmaus
parent 5372c1bcf4
commit 6d74d0383c
15 changed files with 795 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
documentation/extensions/index.md
View File

@ -83,6 +83,7 @@ Experimental Smack Extensions and currently supported XEPs of smack-experimental
| [Internet of Things - Provisioning](iot.md) | [XEP-0324](http://xmpp.org/extensions/xep-0324.html) | Provisioning, access rights and user priviliges for the Internet of Things. |
| [Internet of Things - Control](iot.md) | [XEP-0325](http://xmpp.org/extensions/xep-0325.html) | Describes how to control devices or actuators in an XMPP-based sensor netowrk. |
| [HTTP over XMPP transport](hoxt.md) | [XEP-0332](http://xmpp.org/extensions/xep-0332.html) | Allows to transport HTTP communication over XMPP peer-to-peer networks. |
| Chat Markers | [XEP-0333](http://xmpp.org/extensions/xep-0333.html) | A solution of marking the last received, displayed and acknowledged message in a chat. |
| JSON Containers | [XEP-0335](http://xmpp.org/extensions/xep-0335.html) | Encapsulation of JSON data within XMPP Stanzas. |
| [Internet of Things - Discovery](iot.md) | [XEP-0347](http://xmpp.org/extensions/xep-0347.html) | Describes how Things can be installed and discovered by their owners. |
| Client State Indication | [XEP-0352](http://xmpp.org/extensions/xep-0352.html) | A way for the client to indicate its active/inactive state. |

89
smack-experimental/src/main/java/org/jivesoftware/smackx/chat_markers/ChatMarkersManager.java Normal file
View File

@ -0,0 +1,89 @@
/**
*
* Copyright © 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers;
import java.util.Map;
import java.util.WeakHashMap;
import org.jivesoftware.smack.ConnectionCreationListener;
import org.jivesoftware.smack.Manager;
import org.jivesoftware.smack.SmackException.NoResponseException;
import org.jivesoftware.smack.SmackException.NotConnectedException;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPConnectionRegistry;
import org.jivesoftware.smack.XMPPException.XMPPErrorException;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements;
import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
/**
* Chat Markers Manager class (XEP-0333).
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public final class ChatMarkersManager extends Manager {
static {
XMPPConnectionRegistry.addConnectionCreationListener(new ConnectionCreationListener() {
@Override
public void connectionCreated(XMPPConnection connection) {
getInstanceFor(connection);
}
});
}
private static final Map<XMPPConnection, ChatMarkersManager> INSTANCES = new WeakHashMap<>();
/**
* Get the singleton instance of ChatMarkersManager.
*
* @param connection
* @return the instance of ChatMarkersManager
*/
public static synchronized ChatMarkersManager getInstanceFor(XMPPConnection connection) {
ChatMarkersManager chatMarkersManager = INSTANCES.get(connection);
if (chatMarkersManager == null) {
chatMarkersManager = new ChatMarkersManager(connection);
INSTANCES.put(connection, chatMarkersManager);
}
return chatMarkersManager;
}
private ChatMarkersManager(XMPPConnection connection) {
super(connection);
}
/**
* Returns true if Chat Markers is supported by the server.
*
* @return true if Chat Markers is supported by the server.
* @throws NotConnectedException
* @throws XMPPErrorException
* @throws NoResponseException
* @throws InterruptedException
*/
public boolean isSupportedByServer()
throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
return ServiceDiscoveryManager.getInstanceFor(connection())
.serverSupportsFeature(ChatMarkersElements.NAMESPACE);
}
}

234
smack-experimental/src/main/java/org/jivesoftware/smackx/chat_markers/element/ChatMarkersElements.java Normal file
View File

@ -0,0 +1,234 @@
/**
*
* Copyright © 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers.element;
import org.jivesoftware.smack.packet.ExtensionElement;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.util.XmlStringBuilder;
/**
* Chat Markers elements (XEP-0333).
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public class ChatMarkersElements {
public static final String NAMESPACE = "urn:xmpp:chat-markers:0";
/**
* Markable extension class.
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public static class MarkableExtension implements ExtensionElement {
/**
* markable element.
*/
public static final String ELEMENT = "markable";
public MarkableExtension() {
}
@Override
public String getElementName() {
return ELEMENT;
}
@Override
public String getNamespace() {
return NAMESPACE;
}
@Override
public CharSequence toXML() {
XmlStringBuilder xml = new XmlStringBuilder(this);
xml.closeEmptyElement();
return xml;
}
public static MarkableExtension from(Message message) {
return (MarkableExtension) message.getExtension(ELEMENT, NAMESPACE);
}
}
/**
* Received extension class.
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public static class ReceivedExtension implements ExtensionElement {
/**
* received element.
*/
public static final String ELEMENT = "received";
private final String id;
public ReceivedExtension(String id) {
this.id = id;
}
/**
* Get the id.
*
* @return the id
*/
public String getId() {
return id;
}
@Override
public String getElementName() {
return ELEMENT;
}
@Override
public String getNamespace() {
return NAMESPACE;
}
@Override
public CharSequence toXML() {
XmlStringBuilder xml = new XmlStringBuilder(this);
xml.attribute("id", id);
xml.closeEmptyElement();
return xml;
}
public static ReceivedExtension from(Message message) {
return (ReceivedExtension) message.getExtension(ELEMENT, NAMESPACE);
}
}
/**
* Displayed extension class.
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public static class DisplayedExtension implements ExtensionElement {
/**
* displayed element.
*/
public static final String ELEMENT = "displayed";
private final String id;
public DisplayedExtension(String id) {
this.id = id;
}
/**
* Get the id.
*
* @return the id
*/
public String getId() {
return id;
}
@Override
public String getElementName() {
return ELEMENT;
}
@Override
public String getNamespace() {
return NAMESPACE;
}
@Override
public CharSequence toXML() {
XmlStringBuilder xml = new XmlStringBuilder(this);
xml.attribute("id", id);
xml.closeEmptyElement();
return xml;
}
public static DisplayedExtension from(Message message) {
return (DisplayedExtension) message.getExtension(ELEMENT, NAMESPACE);
}
}
/**
* Acknowledged extension class.
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public static class AcknowledgedExtension implements ExtensionElement {
/**
* acknowledged element.
*/
public static final String ELEMENT = "acknowledged";
private final String id;
public AcknowledgedExtension(String id) {
this.id = id;
}
/**
* Get the id.
*
* @return the id
*/
public String getId() {
return id;
}
@Override
public String getElementName() {
return ELEMENT;
}
@Override
public String getNamespace() {
return NAMESPACE;
}
@Override
public CharSequence toXML() {
XmlStringBuilder xml = new XmlStringBuilder(this);
xml.attribute("id", id);
xml.closeEmptyElement();
return xml;
}
public static AcknowledgedExtension from(Message message) {
return (AcknowledgedExtension) message.getExtension(ELEMENT, NAMESPACE);
}
}
}

24
smack-experimental/src/main/java/org/jivesoftware/smackx/chat_markers/element/package-info.java Normal file
View File

@ -0,0 +1,24 @@
/**
*
* Copyright © 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Chat Markers elements (XEP-0333).
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
*
*/
package org.jivesoftware.smackx.chat_markers.element;

24
smack-experimental/src/main/java/org/jivesoftware/smackx/chat_markers/package-info.java Normal file
View File

@ -0,0 +1,24 @@
/**
*
* Copyright © 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* XEP-0333: Chat Markers.
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
*
*/
package org.jivesoftware.smackx.chat_markers;

39
smack-experimental/src/main/java/org/jivesoftware/smackx/chat_markers/provider/AcknowledgedProvider.java Normal file
View File

@ -0,0 +1,39 @@
/**
*
* Copyright 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers.provider;
import org.jivesoftware.smack.provider.ExtensionElementProvider;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements.AcknowledgedExtension;
import org.xmlpull.v1.XmlPullParser;
/**
* Acknowledged extension provider class (XEP-0333).
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public class AcknowledgedProvider extends ExtensionElementProvider<AcknowledgedExtension> {
@Override
public AcknowledgedExtension parse(XmlPullParser parser, int initialDepth) throws Exception {
String id = parser.getAttributeValue("", "id");
return new AcknowledgedExtension(id);
}
}

39
smack-experimental/src/main/java/org/jivesoftware/smackx/chat_markers/provider/DisplayedProvider.java Normal file
View File

@ -0,0 +1,39 @@
/**
*
* Copyright 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers.provider;
import org.jivesoftware.smack.provider.ExtensionElementProvider;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements.DisplayedExtension;
import org.xmlpull.v1.XmlPullParser;
/**
* Displayed extension provider class (XEP-0333).
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public class DisplayedProvider extends ExtensionElementProvider<DisplayedExtension> {
@Override
public DisplayedExtension parse(XmlPullParser parser, int initialDepth) throws Exception {
String id = parser.getAttributeValue("", "id");
return new DisplayedExtension(id);
}
}

38
smack-experimental/src/main/java/org/jivesoftware/smackx/chat_markers/provider/MarkableProvider.java Normal file
View File

@ -0,0 +1,38 @@
/**
*
* Copyright 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers.provider;
import org.jivesoftware.smack.provider.ExtensionElementProvider;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements.MarkableExtension;
import org.xmlpull.v1.XmlPullParser;
/**
* Markable extension provider class (XEP-0333).
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public class MarkableProvider extends ExtensionElementProvider<MarkableExtension> {
@Override
public MarkableExtension parse(XmlPullParser parser, int initialDepth) throws Exception {
return new MarkableExtension();
}
}

39
smack-experimental/src/main/java/org/jivesoftware/smackx/chat_markers/provider/ReceivedProvider.java Normal file
View File

@ -0,0 +1,39 @@
/**
*
* Copyright 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers.provider;
import org.jivesoftware.smack.provider.ExtensionElementProvider;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements.ReceivedExtension;
import org.xmlpull.v1.XmlPullParser;
/**
* Received extension provider class (XEP-0333).
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
* @author Fernando Ramirez
*
*/
public class ReceivedProvider extends ExtensionElementProvider<ReceivedExtension> {
@Override
public ReceivedExtension parse(XmlPullParser parser, int initialDepth) throws Exception {
String id = parser.getAttributeValue("", "id");
return new ReceivedExtension(id);
}
}

24
smack-experimental/src/main/java/org/jivesoftware/smackx/chat_markers/provider/package-info.java Normal file
View File

@ -0,0 +1,24 @@
/**
*
* Copyright © 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* Chat Markers providers (XEP-0333).
*
* @see <a href="http://xmpp.org/extensions/xep-0333.html">XEP-0333: Chat
* Markers</a>
*
*/
package org.jivesoftware.smackx.chat_markers.provider;

22
smack-experimental/src/main/resources/org.jivesoftware.smack.experimental/experimental.providers
View File

@ -211,4 +211,26 @@
<className>org.jivesoftware.smackx.push_notifications.provider.RemoteDisablingProvider</className>
</extensionProvider>
<!-- XEP-0333: Chat Markers -->
<extensionProvider>
<elementName>markable</elementName>
<namespace>urn:xmpp:chat-markers:0</namespace>
<className>org.jivesoftware.smackx.chat_markers.provider.MarkableProvider</className>
</extensionProvider>
<extensionProvider>
<elementName>received</elementName>
<namespace>urn:xmpp:chat-markers:0</namespace>
<className>org.jivesoftware.smackx.chat_markers.provider.ReceivedProvider</className>
</extensionProvider>
<extensionProvider>
<elementName>displayed</elementName>
<namespace>urn:xmpp:chat-markers:0</namespace>
<className>org.jivesoftware.smackx.chat_markers.provider.DisplayedProvider</className>
</extensionProvider>
<extensionProvider>
<elementName>acknowledged</elementName>
<namespace>urn:xmpp:chat-markers:0</namespace>
<className>org.jivesoftware.smackx.chat_markers.provider.AcknowledgedProvider</className>
</extensionProvider>
</smackProviders>

55
smack-experimental/src/test/java/org/jivesoftware/smackx/chat_markers/AcknowledgedExtensionTest.java Normal file
View File

@ -0,0 +1,55 @@
/**
*
* Copyright © 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.util.PacketParserUtils;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements.AcknowledgedExtension;
import org.jivesoftware.smackx.chat_markers.provider.AcknowledgedProvider;
import org.junit.Assert;
import org.junit.Test;
import org.jxmpp.jid.impl.JidCreate;
import org.xmlpull.v1.XmlPullParser;
public class AcknowledgedExtensionTest {
String acknowledgedMessageStanza = "<message to='northumberland@shakespeare.lit/westminster' id='message-2'>"
+ "<acknowledged xmlns='urn:xmpp:chat-markers:0' id='message-1'/>" + "</message>";
String acknowledgedExtension = "<acknowledged xmlns='urn:xmpp:chat-markers:0' id='message-1'/>";
@Test
public void checkDisplayedExtension() throws Exception {
Message message = new Message(JidCreate.from("northumberland@shakespeare.lit/westminster"));
message.setStanzaId("message-2");
message.addExtension(new ChatMarkersElements.AcknowledgedExtension("message-1"));
Assert.assertEquals(acknowledgedMessageStanza, message.toXML().toString());
}
@Test
public void checkDisplayedProvider() throws Exception {
XmlPullParser parser = PacketParserUtils.getParserFor(acknowledgedExtension);
AcknowledgedExtension acknowledgedExtension1 = new AcknowledgedProvider().parse(parser);
Assert.assertEquals("message-1", acknowledgedExtension1.getId());
Message message = (Message) PacketParserUtils.parseStanza(acknowledgedMessageStanza);
AcknowledgedExtension acknowledgedExtension2 = AcknowledgedExtension.from(message);
Assert.assertEquals("message-1", acknowledgedExtension2.getId());
}
}

55
smack-experimental/src/test/java/org/jivesoftware/smackx/chat_markers/DisplayedExtensionTest.java Normal file
View File

@ -0,0 +1,55 @@
/**
*
* Copyright © 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.util.PacketParserUtils;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements.DisplayedExtension;
import org.jivesoftware.smackx.chat_markers.provider.DisplayedProvider;
import org.junit.Assert;
import org.junit.Test;
import org.jxmpp.jid.impl.JidCreate;
import org.xmlpull.v1.XmlPullParser;
public class DisplayedExtensionTest {
String displayedMessageStanza = "<message to='northumberland@shakespeare.lit/westminster' id='message-2'>"
+ "<displayed xmlns='urn:xmpp:chat-markers:0' id='message-1'/>" + "</message>";
String displayedExtension = "<displayed xmlns='urn:xmpp:chat-markers:0' id='message-1'/>";
@Test
public void checkDisplayedExtension() throws Exception {
Message message = new Message(JidCreate.from("northumberland@shakespeare.lit/westminster"));
message.setStanzaId("message-2");
message.addExtension(new ChatMarkersElements.DisplayedExtension("message-1"));
Assert.assertEquals(displayedMessageStanza, message.toXML().toString());
}
@Test
public void checkDisplayedProvider() throws Exception {
XmlPullParser parser = PacketParserUtils.getParserFor(displayedExtension);
DisplayedExtension displayedExtension1 = new DisplayedProvider().parse(parser);
Assert.assertEquals("message-1", displayedExtension1.getId());
Message message = (Message) PacketParserUtils.parseStanza(displayedMessageStanza);
DisplayedExtension displayedExtension2 = DisplayedExtension.from(message);
Assert.assertEquals("message-1", displayedExtension2.getId());
}
}

57
smack-experimental/src/test/java/org/jivesoftware/smackx/chat_markers/MarkableExtensionTest.java Normal file
View File

@ -0,0 +1,57 @@
/**
*
* Copyright © 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.util.PacketParserUtils;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements.MarkableExtension;
import org.jivesoftware.smackx.chat_markers.provider.MarkableProvider;
import org.junit.Assert;
import org.junit.Test;
import org.jxmpp.jid.impl.JidCreate;
import org.xmlpull.v1.XmlPullParser;
public class MarkableExtensionTest {
String markableMessageStanza = "<message to='ingrichard@royalty.england.lit/throne' id='message-1'>"
+ "<body>My lord, dispatch; read o&apos;er these articles.</body>"
+ "<markable xmlns='urn:xmpp:chat-markers:0'/>" + "</message>";
String markableExtension = "<markable xmlns='urn:xmpp:chat-markers:0'/>";
@Test
public void checkMarkableExtension() throws Exception {
Message message = new Message(JidCreate.from("ingrichard@royalty.england.lit/throne"));
message.setStanzaId("message-1");
message.setBody("My lord, dispatch; read o'er these articles.");
message.addExtension(new ChatMarkersElements.MarkableExtension());
Assert.assertEquals(markableMessageStanza, message.toXML().toString());
}
@Test
public void checkMarkableProvider() throws Exception {
XmlPullParser parser = PacketParserUtils.getParserFor(markableExtension);
MarkableExtension markableExtension1 = new MarkableProvider().parse(parser);
Assert.assertEquals(markableExtension, markableExtension1.toXML().toString());
Message message = (Message) PacketParserUtils.parseStanza(markableMessageStanza);
MarkableExtension markableExtension2 = MarkableExtension.from(message);
Assert.assertEquals(markableExtension, markableExtension2.toXML().toString());
}
}

55
smack-experimental/src/test/java/org/jivesoftware/smackx/chat_markers/ReceivedExtensionTest.java Normal file
View File

@ -0,0 +1,55 @@
/**
*
* Copyright © 2016 Fernando Ramirez
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jivesoftware.smackx.chat_markers;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.util.PacketParserUtils;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements;
import org.jivesoftware.smackx.chat_markers.element.ChatMarkersElements.ReceivedExtension;
import org.jivesoftware.smackx.chat_markers.provider.ReceivedProvider;
import org.junit.Assert;
import org.junit.Test;
import org.jxmpp.jid.impl.JidCreate;
import org.xmlpull.v1.XmlPullParser;
public class ReceivedExtensionTest {
String receivedMessageStanza = "<message to='northumberland@shakespeare.lit/westminster' id='message-2'>"
+ "<received xmlns='urn:xmpp:chat-markers:0' id='message-1'/>" + "</message>";
String receivedExtension = "<received xmlns='urn:xmpp:chat-markers:0' id='message-1'/>";
@Test
public void checkReceivedExtension() throws Exception {
Message message = new Message(JidCreate.from("northumberland@shakespeare.lit/westminster"));
message.setStanzaId("message-2");
message.addExtension(new ChatMarkersElements.ReceivedExtension("message-1"));
Assert.assertEquals(receivedMessageStanza, message.toXML().toString());
}
@Test
public void checkReceivedProvider() throws Exception {
XmlPullParser parser = PacketParserUtils.getParserFor(receivedExtension);
ReceivedExtension receivedExtension1 = new ReceivedProvider().parse(parser);
Assert.assertEquals("message-1", receivedExtension1.getId());
Message message = (Message) PacketParserUtils.parseStanza(receivedMessageStanza);
ReceivedExtension receivedExtension2 = ReceivedExtension.from(message);
Assert.assertEquals("message-1", receivedExtension2.getId());
}
}