6:53 p.m.
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/jira/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test. In
that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
6:19 p.m.
New subject: [JBoss JIRA] Commented: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/jira/browse/ARQ-126?page=com.atlassian.jira.plugin...
]
Aslak Knutsen commented on ARQ-126:
-----------------------------------
What about CLIENT and IN_CONTAINER ?
Client as in, your just like a client will be. Remote EJBs, HTTP etc.
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/jira/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
6:51 p.m.
New subject: [JBoss JIRA] Commented: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/jira/browse/ARQ-126?page=com.atlassian.jira.plugin...
]
Dan Allen commented on ARQ-126:
-------------------------------
I like CLIENT. Makes sense to me. That really keeps it clear, rather than the somewhat
vague meaning of "local".
+1
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/jira/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:27 a.m.
New subject: [JBoss JIRA] Commented: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/jira/browse/ARQ-126?page=com.atlassian.jira.plugin...
]
Dan Allen commented on ARQ-126:
-------------------------------
A better idea just dawned on me. We should try to make the annotation and value read like
a sentence. Then, there can be no mistake.
Consider:
@RunWith(Arquillian.class)
@Execute(AS_CLIENT)
public class ClientArquillianTest { ... }
@RunWith(Arquillian.class)
@Execute(IN_CONTAINER)
public class InContainerArquillianTest { ... }
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/jira/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:30 a.m.
New subject: [JBoss JIRA] Commented: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/jira/browse/ARQ-126?page=com.atlassian.jira.plugin...
]
Dan Allen commented on ARQ-126:
-------------------------------
In that case, it would be:
public enum ExecuteModeType
{
/**
* In AS_CLIENT mode, the @Deployment is processed and deployed to the Container,
* but the test is executed as a client of the container.
*/
AS_CLIENT,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
This is consistent with the wording we have used in our mission statement.
(We have to put the verb in the enum rather than the enum since it's not parallel in
the two sentence clauses). I guess another alternative would be:
@RunWith(Arquillian.class)
@ExecuteAs(CLIENT)
public class ClientArquillianTest { ... }
@RunWith(Arquillian.class)
@ExecuteAs(IN_CONTAINER) // reads a bit strange, but optional anyway
public class InContainerArquillianTest { ... }
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/jira/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:32 a.m.
New subject: [JBoss JIRA] Commented: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/jira/browse/ARQ-126?page=com.atlassian.jira.plugin...
]
Dan Allen commented on ARQ-126:
-------------------------------
Oh, wait. Perhaps an even better alternative if we want the verb in the annotation:
@RunWith(Arquillian.class)
@ExecuteFrom(CLIENT)
public class ClientArquillianTest { ... }
@RunWith(Arquillian.class)
@ExecuteFrom(IN_CONTAINER) // or WITHIN_CONTAINER
public class InContainerArquillianTest { ... }
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/jira/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
4:52 a.m.
New subject: [JBoss JIRA] Commented: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/jira/browse/ARQ-126?page=com.atlassian.jira.plugin...
]
Aslak Knutsen commented on ARQ-126:
-----------------------------------
What about using @Run?
@RunWith(Arquillian.class)
@Run(IN_CONTAINER)
public class InjectionTestCase
@RunWith(Arquillian.class)
@Run(AS_CLIENT)
public class InjectionTestCase
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/jira/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
1:32 p.m.
New subject: [JBoss JIRA] Commented: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/jira/browse/ARQ-126?page=com.atlassian.jira.plugin...
]
Andrew Lee Rubinger commented on ARQ-126:
-----------------------------------------
(02:25:04 PM) aslak: ALR, comments on ARQ-126 ?
(02:25:05 PM) jbossbot: [ARQ-126] rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[Open, Major, Unassigned] http://jira.jboss.org/jira/browse/ARQ-126
(02:25:48 PM) ALR@Freenode: aslak: Does that affect packaging?
(02:26:14 PM) aslak: RunMode?
(02:26:22 PM) ALR@Freenode: Or the proposed @Run, yes
(02:26:28 PM) aslak: yes
(02:26:43 PM) ALR@Freenode: aslak: Then IMO it should be atop @Deployment
(02:26:54 PM) ALR@Freenode: Where the deployable archive is declared
(02:27:10 PM) ALR@Freenode: Else I find it unclear what's gonna happen under the
covers.
(02:27:14 PM) aslak: RunMode exists now, but the same arquillian packaging happens either
way you run it, just that its executed locally
(02:27:20 PM) ALR@Freenode: Right.
(02:27:30 PM) ALR@Freenode: Your last comments work best IMO from a grammar perspective.
(02:27:32 PM) aslak: ARQ_134
(02:27:36 PM) ALR@Freenode: @Run(IN_CONTAINER)
(02:27:36 PM) aslak: ARQ-134
(02:27:36 PM) jbossbot: [ARQ-134] RunMode LOCAL changes deployment. [Open, Major, Aslak
Knutsen] http://jira.jboss.org/jira/browse/ARQ-134
(02:27:42 PM) ALR@Freenode: @Run(AS_CLIENT)
(02:27:46 PM) ALR@Freenode: But it affects packaging
(02:28:00 PM) ALR@Freenode: And I've always felt that becomes a property of the
@Deployment
(02:28:09 PM) ALR@Freenode: Because in effect we change the deployment. :)
(02:28:10 PM) aslak: hmmm
(02:28:38 PM) aslak: i see your point
(02:28:50 PM) aslak: it effects more then just packaging tho, but
(02:28:55 PM) ALR@Freenode: Yeah, I know. :)
(02:29:11 PM) ALR@Freenode: Again, I love the in-container feature.
(02:29:29 PM) ALR@Freenode: Would love even more to find a way to make it plain what
we're doing to enable it though
(02:29:46 PM) ALR@Freenode: Because of the lack of EAR support, changing JNDI names,
etc... everything that results from wrapping.
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/jira/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:06 p.m.
New subject: [JBoss JIRA] Resolved: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/browse/ARQ-126?page=com.atlassian.jira.plugin.syst...
]
Aslak Knutsen resolved ARQ-126.
-------------------------------
Fix Version/s: 1.0.0.Alpha2
Resolution: Done
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
Fix For: 1.0.0.Alpha2
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
3:08 p.m.
New subject: [JBoss JIRA] Assigned: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/browse/ARQ-126?page=com.atlassian.jira.plugin.syst...
]
Aslak Knutsen reassigned ARQ-126:
---------------------------------
Assignee: Aslak Knutsen
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
Assignee: Aslak Knutsen
Fix For: 1.0.0.Alpha2
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
9:10 a.m.
New subject: [JBoss JIRA] Closed: (ARQ-126) rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
[
https://jira.jboss.org/browse/ARQ-126?page=com.atlassian.jira.plugin.syst...
]
Aslak Knutsen closed ARQ-126.
-----------------------------
Alpha-2 published
rename RunModeType.REMOTE to RunModeType.IN_CONTAINER
-----------------------------------------------------
Key: ARQ-126
URL: https://jira.jboss.org/browse/ARQ-126
Project: Arquillian
Issue Type: Bug
Affects Versions: 1.0.0.Alpha2
Reporter: Dan Allen
Assignee: Aslak Knutsen
Fix For: 1.0.0.Alpha2
I think that the combination of the terms LOCAL and REMOTE in the RunModeType enum is
confusing. RunModeType is attempting to describe where the test runs in relationship to
the test runner. In that case, the terms are defensible.
LOCAL = test is local to the test runner (same JVM)
REMOTE = test is remote from the test runner (different JVM)
In the case of LOCAL, the test must use remote communication to invoke the code under
test. This is where we overuse the term "remote". The term "remote"
implies remote communication, but it's not clear what is remote from the standpoint of
the test writer. We are describing internal behavior. And besides, REMOTE isn't
entirely accurate since in embedded containers, no remote communication is used.
It's more natural to describe where the test is in relation to the code under test.
In that case, local means that the test case stays behind. The other term would be
in-container, which may or may not be remote. It's about the packaging. The test is
with the test code executing in the container.
I'd like to propose these constants instead:
public enum RunModeType
{
/**
* In LOCAL mode, the @Deployment is processed and deployed to the Container,
* but the test is not executed inside the container. It's local to the test
runner.
*/
LOCAL,
/**
* In IN_CONTAINER mode, the @Deployment is processed and deployed to the container
along side the test
* case and the test case is executed inside the container.<br/>
* This is the default mode when none specified.
*/
IN_CONTAINER
}
Perhaps I'm just thinking about it wrong, but I just can't get my mind to believe
that @RunMode(REMOTE) means that the test case is running in the container. I get how it
is technically correct, but human tendency leads me to believe we are going to have to
constantly clarify this. @RunMode(IN_CONTAINER) makes it clear that the test is getting
relocated to the container.
(I'm even open to changing LOCAL to NORMAL if you think it helps the terminology)
--
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
https://jira.jboss.org/secure/Administrators.jspa
-
For more information on JIRA, see: http://www.atlassian.com/software/jira
5130
days inactive
5157
days old
arquillian-issues@lists.jboss.org
10 comments
3 participants
participants (3)
-
Andrew Lee Rubinger (JIRA) -
Aslak Knutsen (JIRA)
-
Dan Allen (JIRA)